prompt
stringlengths 19
879k
| completion
stringlengths 3
53.8k
| api
stringlengths 8
59
|
|---|---|---|
# Copyright 2021 Sony Semiconductors Israel, Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
import unittest
import numpy as np
from model_compression_toolkit.common.collectors.statistics_collector import StatsCollector
from model_compression_toolkit.common.collectors.statistics_collector import scale_statistics
from model_compression_toolkit.common.collectors.statistics_collector import shift_statistics
from model_compression_toolkit.common.framework_info import ChannelAxis
def init_stats_container(num_of_input_channels, init_min=None, init_max=None):
sc = StatsCollector(init_min_value=init_min, init_max_value=init_max, output_channel_index=ChannelAxis.NHWC)
x = np.random.rand(1, 2, 3, num_of_input_channels)
for i in range(100):
sc.update_statistics(x)
return sc
def scale_stats_container(sc, num_of_scaling_factors):
scaling_factor = np.random.random(num_of_scaling_factors)
scaled_sc = scale_statistics(sc, scaling_factor)
return scaled_sc, scaling_factor
def shift_stats_container(sc, num_of_shifting_factors):
shifting_factor = np.random.random(num_of_shifting_factors)
shifted_sc = shift_statistics(sc, shifting_factor)
return shifted_sc, shifting_factor
class TestCollectorsManipulations(unittest.TestCase):
########### Test scaling ###########
def test_mean_scale_per_channel(self, num_of_scaling_factors=10):
sc = init_stats_container(num_of_scaling_factors)
mean = sc.get_mean()
scaled_sc, scaling_factor = scale_stats_container(sc, num_of_scaling_factors)
scaled_mean = scaled_sc.get_mean()
self.assertTrue(np.allclose(scaled_mean / scaling_factor, mean))
def test_mean_scale_per_tensor(self, num_of_scaling_factors=1):
sc = init_stats_container(num_of_scaling_factors)
mean = sc.get_mean()
scaled_sc, scaling_factor = scale_stats_container(sc, num_of_scaling_factors)
scaled_mean = scaled_sc.get_mean()
self.assertTrue(np.allclose(scaled_mean / scaling_factor, mean))
def test_histogram_scale_per_channel(self, num_of_scaling_factors=10):
sc = init_stats_container(num_of_scaling_factors)
bins, _ = sc.hc.get_histogram()
scaled_sc, scaling_factor = scale_stats_container(sc, num_of_scaling_factors)
with self.assertRaises(Exception):
scaled_sc.hc.get_histogram() # data is corrupted. expect exception
def test_histogram_scale_per_tensor(self, num_of_scaling_factors=1):
sc = init_stats_container(num_of_scaling_factors)
bins, _ = sc.hc.get_histogram()
scaled_sc, scaling_factor = scale_stats_container(sc, num_of_scaling_factors)
scaled_bins, _ = scaled_sc.hc.get_histogram()
self.assertTrue(np.allclose(scaled_bins / scaling_factor, bins))
def test_min_max_scale_per_channel(self, num_of_scaling_factors=10):
sc = init_stats_container(num_of_scaling_factors)
min_pc, max_pc = sc.mpcc.min_per_channel, sc.mpcc.max_per_channel
scaled_sc, scaling_factor = scale_stats_container(sc, num_of_scaling_factors)
min_pc_scaled, max_pc_scaled = scaled_sc.mpcc.min_per_channel, scaled_sc.mpcc.max_per_channel
self.assertTrue(np.allclose(min_pc_scaled / scaling_factor, min_pc))
self.assertTrue( | np.allclose(max_pc_scaled / scaling_factor, max_pc) | numpy.allclose |
from sklearn.metrics.pairwise import rbf_kernel
from scipy.stats import ks_2samp
from scipy.stats import wilcoxon
import numpy as np
import random
from scipy import stats
import time
from collections import defaultdict
import numpy as np
import warnings
from scipy.stats import rankdata
def same(x):
return x
def cube(x):
return np.power(x, 3)
def negexp(x):
return np.exp(-np.abs(x))
def generate_samples_random(size=1000, sType='CI', dx=1, dy=1, dz=20, nstd=1, fixed_function='linear',
debug=False, normalize = True, seed = None, dist_z = 'gaussian'):
'''Generate CI,I or NI post-nonlinear samples
1. Z is independent Gaussian or Laplace
2. X = f1(<a,Z> + b + noise) and Y = f2(<c,Z> + d + noise) in case of CI
Arguments:
size : number of samples
sType: CI, I, or NI
dx: Dimension of X
dy: Dimension of Y
dz: Dimension of Z
nstd: noise standard deviation
f1, f2 to be within {x,x^2,x^3,tanh x, e^{-|x|}, cos x}
Output:
Samples X, Y, Z
'''
if seed == None:
np.random.seed()
else:
np.random.seed(seed)
if fixed_function == 'linear':
f1 = same
f2 = same
else:
I1 = random.randint(2, 6)
I2 = random.randint(2, 6)
if I1 == 2:
f1 = np.square
elif I1 == 3:
f1 = cube
elif I1 == 4:
f1 = np.tanh
elif I1 == 5:
f1 = negexp
else:
f1 = np.cos
if I2 == 2:
f2 = np.square
elif I2 == 3:
f2 = cube
elif I2 == 4:
f2 = np.tanh
elif I2 == 5:
f2 = negexp
else:
f2 = np.cos
if debug:
print(f1, f2)
num = size
if dist_z =='gaussian':
cov = np.eye(dz)
mu = np.ones(dz)
Z = np.random.multivariate_normal(mu, cov, num)
Z = np.matrix(Z)
elif dist_z == 'laplace':
Z = np.random.laplace(loc=0.0, scale=1.0, size=num*dz)
Z = np.reshape(Z,(num,dz))
Z = np.matrix(Z)
Ax = np.random.rand(dz, dx)
for i in range(dx):
Ax[:, i] = Ax[:, i] / np.linalg.norm(Ax[:, i], ord=1)
Ax = np.matrix(Ax)
Ay = np.random.rand(dz, dy)
for i in range(dy):
Ay[:, i] = Ay[:, i] / np.linalg.norm(Ay[:, i], ord=1)
Ay = np.matrix(Ay)
Axy = np.random.rand(dx, dy)
for i in range(dy):
Axy[:, i] = Axy[:, i] / np.linalg.norm(Axy[:, i], ord=1)
Axy = np.matrix(Axy)
temp = Z * Ax
m = np.mean(np.abs(temp))
nstd = nstd * m
if sType == 'CI':
X = f1(Z * Ax + nstd * np.random.multivariate_normal(np.zeros(dx), np.eye(dx), num))
Y = f2(Z * Ay + nstd * np.random.multivariate_normal(np.zeros(dy), np.eye(dy), num))
elif sType == 'I':
X = f1(nstd * np.random.multivariate_normal(np.zeros(dx), np.eye(dx), num))
Y = f2(nstd * np.random.multivariate_normal(np.zeros(dy), np.eye(dy), num))
else:
X = np.random.multivariate_normal(np.zeros(dx), np.eye(dx), num)
Y = f2(2 * X * Axy + Z * Ay)
if normalize == True:
Z = (Z - Z.min()) / (Z.max() - Z.min())
X = (X - X.min()) / (X.max() - X.min())
Y = (Y - Y.min()) / (Y.max() - Y.min())
return np.array(X), np.array(Y), np.array(Z)
def pc_ks(pvals):
""" Compute the area under power curve and the Kolmogorov-Smirnoff
test statistic of the hypothesis that pvals come from the uniform
distribution with support (0, 1).
"""
if pvals.size == 0:
return [-1, -1]
if -1 in pvals or -2 in pvals:
return [-1, -1]
pvals = np.sort(pvals)
cdf = ecdf(pvals)
auc = 0
for (pv1, pv2) in zip(pvals[:-1], pvals[1:]):
auc += integrate.quad(cdf, pv1, pv2)[0]
auc += integrate.quad(cdf, pvals[-1], 1)[0]
_, ks = kstest(pvals, 'uniform')
return auc, ks
def np2r(x):
""" Convert a numpy array to an R matrix.
Args:
x (dim0, dim1): A 2d numpy array.
Returns:
x_r: An rpy2 object representing an R matrix isometric to x.
"""
if 'rpy2' not in sys.modules:
raise ImportError(("rpy2 is not installed.",
" Cannot convert a numpy array to an R vector."))
try:
dim0, dim1 = x.shape
except IndexError:
raise IndexError("Only 2d arrays are supported")
return R.r.matrix(R.FloatVector(x.flatten()), nrow=dim0, ncol=dim1)
def fdr(truth, pred, axis=None):
""" Computes False discovery rate
"""
return ((pred==1) & (truth==0)).sum(axis=axis) / pred.sum(axis=axis).astype(float).clip(1,np.inf)
def tpr(truth, pred, axis=None):
""" Computes true positive rate
"""
return ((pred==1) & (truth==1)).sum(axis=axis) / truth.sum(axis=axis).astype(float).clip(1,np.inf)
def true_positives(truth, pred, axis=None):
""" Computes number of true positive
"""
return ((pred==1) & (truth==1)).sum(axis=axis)
def false_positives(truth, pred, axis=None):
""" Computes number of false positive
"""
return ((pred==1) & (truth==0)).sum(axis=axis)
def bh(p, fdr):
""" From vector of p-values and desired false positive rate,
returns significant p-values with Benjamini-Hochberg correction
"""
p_orders = np.argsort(p)
discoveries = []
m = float(len(p_orders))
for k, s in enumerate(p_orders):
if p[s] <= (k+1) / m * fdr:
discoveries.append(s)
else:
break
return np.array(discoveries, dtype=int)
def mmd_squared(X, Y, gamma = 1):
X = X.reshape((len(X)), 1)
Y = Y.reshape((len(Y)), 1)
K_XX = rbf_kernel(X, gamma=gamma)
K_YY = rbf_kernel(Y, gamma=gamma)
K_XY = rbf_kernel(X, Y, gamma=gamma)
n = K_XX.shape[0]
m = K_YY.shape[0]
mmd_squared = (np.sum(K_XX)-np.trace(K_XX))/(n*(n-1)) + (np.sum(K_YY)-np.trace(K_YY))/(m*(m-1)) - 2 * np.sum(K_XY) / (m * n)
return mmd_squared
def correlation(X,Y):
X = X.reshape((len(X)))
Y = Y.reshape((len(Y)))
return np.abs(np.corrcoef(X, Y)[0, 1])
def kolmogorov(X,Y):
X = X.reshape((len(X)))
Y = Y.reshape((len(Y)))
return ks_2samp(X, Y)[0]
def wilcox(X,Y):
X = X.reshape((len(X)))
Y = Y.reshape((len(Y)))
return wilcoxon(X, Y)[0]
'''
X = np.random.normal(0,2,500)
Y = np.random.normal(0,2,500)
kolmogorov(X,Y)
'''
def rdc(x, y, f=np.sin, k=20, s=1/6., n=1):
"""
Computes the Randomized Dependence Coefficient
x,y: numpy arrays 1-D or 2-D
If 1-D, size (samples,)
If 2-D, size (samples, variables)
f: function to use for random projection
k: number of random projections to use
s: scale parameter
n: number of times to compute the RDC and
return the median (for stability)
According to the paper, the coefficient should be relatively insensitive to
the settings of the f, k, and s parameters.
Source: https://github.com/garydoranjr/rdc
"""
x = x.reshape((len(x)))
y = y.reshape((len(y)))
if n > 1:
values = []
for i in range(n):
try:
values.append(rdc(x, y, f, k, s, 1))
except np.linalg.linalg.LinAlgError: pass
return np.median(values)
if len(x.shape) == 1: x = x.reshape((-1, 1))
if len(y.shape) == 1: y = y.reshape((-1, 1))
# Copula Transformation
cx = np.column_stack([rankdata(xc, method='ordinal') for xc in x.T])/float(x.size)
cy = np.column_stack([rankdata(yc, method='ordinal') for yc in y.T])/float(y.size)
# Add a vector of ones so that w.x + b is just a dot product
O = np.ones(cx.shape[0])
X = np.column_stack([cx, O])
Y = np.column_stack([cy, O])
# Random linear projections
Rx = (s/X.shape[1])*np.random.randn(X.shape[1], k)
Ry = (s/Y.shape[1])*np.random.randn(Y.shape[1], k)
X = np.dot(X, Rx)
Y = np.dot(Y, Ry)
# Apply non-linear function to random projections
fX = f(X)
fY = f(Y)
# Compute full covariance matrix
C = np.cov(np.hstack([fX, fY]).T)
# Due to numerical issues, if k is too large,
# then rank(fX) < k or rank(fY) < k, so we need
# to find the largest k such that the eigenvalues
# (canonical correlations) are real-valued
k0 = k
lb = 1
ub = k
while True:
# Compute canonical correlations
Cxx = C[:k, :k]
Cyy = C[k0:k0+k, k0:k0+k]
Cxy = C[:k, k0:k0+k]
Cyx = C[k0:k0+k, :k]
eigs = np.linalg.eigvals(np.dot(np.dot( | np.linalg.pinv(Cxx) | numpy.linalg.pinv |
import unittest
from datetime import date
from irLib.marketConvention.dayCount import ACT_ACT
from irLib.marketConvention.compounding import annually_k_Spot
from irLib.helpers.yieldCurve import yieldCurve, discountCurve, forwardCurve
import numpy as np
alias_disC = 'disC'
alias_forC = 'forC'
referenceDate = date(2020, 6, 26)
dayCount = ACT_ACT()
compounding = annually_k_Spot()
allowExtrapolation = False
# set synthetic data
timeIndex = [1, 2, 3, 4, 5]
flatR = 0.03
dF = ((flatR + 1) ** -np.arange(1, 6)).tolist()
forwardRates = (flatR * np.ones(5)).tolist()
spots = (flatR * np.ones(5)).tolist()
yearFrac = np.arange(1, 6).tolist()
par = (flatR * | np.ones(5) | numpy.ones |
import os
import numpy as np
import scipy.sparse as sp
import pickle
import torch
from torch.utils.data import DataLoader
from dgl.data.utils import download, _get_dgl_url, get_download_dir, extract_archive
import random
import time
import dgl
from utils import shuffle_walks
#np.random.seed(3141592653)
def ReadTxtNet(file_path="", undirected=True):
""" Read the txt network file.
Notations: The network is unweighted.
Parameters
----------
file_path str : path of network file
undirected bool : whether the edges are undirected
Return
------
net dict : a dict recording the connections in the graph
node2id dict : a dict mapping the nodes to their embedding indices
id2node dict : a dict mapping nodes embedding indices to the nodes
"""
if file_path == 'youtube' or file_path == 'blog':
name = file_path
dir = get_download_dir()
zip_file_path='{}/{}.zip'.format(dir, name)
download(_get_dgl_url(os.path.join('dataset/DeepWalk/', '{}.zip'.format(file_path))), path=zip_file_path)
extract_archive(zip_file_path,
'{}/{}'.format(dir, name))
file_path = "{}/{}/{}-net.txt".format(dir, name, name)
node2id = {}
id2node = {}
cid = 0
src = []
dst = []
net = {}
with open(file_path, "r") as f:
for line in f.readlines():
n1, n2 = list(map(int, line.strip().split(" ")[:2]))
if n1 not in node2id:
node2id[n1] = cid
id2node[cid] = n1
cid += 1
if n2 not in node2id:
node2id[n2] = cid
id2node[cid] = n2
cid += 1
n1 = node2id[n1]
n2 = node2id[n2]
if n1 not in net:
net[n1] = {n2: 1}
src.append(n1)
dst.append(n2)
elif n2 not in net[n1]:
net[n1][n2] = 1
src.append(n1)
dst.append(n2)
if undirected:
if n2 not in net:
net[n2] = {n1: 1}
src.append(n2)
dst.append(n1)
elif n1 not in net[n2]:
net[n2][n1] = 1
src.append(n2)
dst.append(n1)
print("node num: %d" % len(net))
print("edge num: %d" % len(src))
assert max(net.keys()) == len(net) - 1, "error reading net, quit"
sm = sp.coo_matrix(
(np.ones(len(src)), (src, dst)),
dtype=np.float32)
return net, node2id, id2node, sm
def net2graph(net_sm):
""" Transform the network to DGL graph
Return
------
G DGLGraph : graph by DGL
"""
start = time.time()
G = dgl.DGLGraph(net_sm)
end = time.time()
t = end - start
print("Building DGLGraph in %.2fs" % t)
return G
class DeepwalkDataset:
def __init__(self,
net_file,
map_file,
walk_length=80,
window_size=5,
num_walks=10,
batch_size=32,
negative=5,
gpus=[0],
fast_neg=True,
):
""" This class has the following functions:
1. Transform the txt network file into DGL graph;
2. Generate random walk sequences for the trainer;
3. Provide the negative table if the user hopes to sample negative
nodes according to nodes' degrees;
Parameter
---------
net_file str : path of the txt network file
walk_length int : number of nodes in a sequence
window_size int : context window size
num_walks int : number of walks for each node
batch_size int : number of node sequences in each batch
negative int : negative samples for each positve node pair
fast_neg bool : whether do negative sampling inside a batch
"""
self.walk_length = walk_length
self.window_size = window_size
self.num_walks = num_walks
self.batch_size = batch_size
self.negative = negative
self.num_procs = len(gpus)
self.fast_neg = fast_neg
self.net, self.node2id, self.id2node, self.sm = ReadTxtNet(net_file)
self.save_mapping(map_file)
self.G = net2graph(self.sm)
# random walk seeds
start = time.time()
seeds = torch.cat([torch.LongTensor(self.G.nodes())] * num_walks)
self.seeds = torch.split(shuffle_walks(seeds), int(np.ceil(len(self.net) * self.num_walks / self.num_procs)), 0)
end = time.time()
t = end - start
print("%d seeds in %.2fs" % (len(seeds), t))
# negative table for true negative sampling
if not fast_neg:
node_degree = np.array(list(map(lambda x: len(self.net[x]), self.net.keys())))
node_degree = np.power(node_degree, 0.75)
node_degree /= np.sum(node_degree)
node_degree = np.array(node_degree * 1e8, dtype=np.int)
self.neg_table = []
for idx, node in enumerate(self.net.keys()):
self.neg_table += [node] * node_degree[idx]
self.neg_table_size = len(self.neg_table)
self.neg_table = | np.array(self.neg_table, dtype=np.long) | numpy.array |
import os
from typing import Any, Union
import logging
import math
import matplotlib
from matplotlib import pyplot as plt
import numpy as np
import cv2
from ipso_phen.ipapi.file_handlers.fh_base import file_handler_factory
from ipso_phen.ipapi.base.image_wrapper import ImageWrapper
import ipso_phen.ipapi.base.ip_common as ipc
from ipso_phen.ipapi.tools.comand_line_wrapper import ArgWrapper
from ipso_phen.ipapi.tools.regions import (
CircleRegion,
RectangleRegion,
EmptyRegion,
Point,
AbstractRegion,
)
from ipso_phen.ipapi.tools.common_functions import time_method, force_directories
matplotlib.use("agg")
KLC_FULLY_INSIDE = dict(val=0, color=ipc.C_GREEN)
KLC_OVERLAPS = dict(val=1, color=ipc.C_BLUE)
KLC_PROTECTED_DIST_OK = dict(val=2, color=ipc.C_LIGHT_STEEL_BLUE)
KLC_PROTECTED_SIZE_OK = dict(val=3, color=ipc.C_CABIN_BLUE)
KLC_OK_TOLERANCE = dict(val=4, color=ipc.C_TEAL)
KLC_NO_BIG_ENOUGH = dict(val=5, color=ipc.C_FUCHSIA)
KLC_NO_CLOSE_ENOUGH = dict(val=6, color=ipc.C_ORANGE)
KLC_OUTSIDE = dict(val=7, color=ipc.C_RED)
KLC_BIG_ENOUGH_TO_IGNORE_DISTANCE = dict(val=8, color=ipc.C_LIME)
logger = logging.getLogger(__name__)
class ImageListHolder:
def __init__(self, file_list, database):
self.image_list = [
file_handler_factory(file_path_, database=database)
for file_path_ in file_list
]
def __len__(self):
return len(self.image_list)
def retrieve_image(self, key, value):
"""Return an image based on key value
:param key: one of the wrapper properties
:param value: value
:return: image
"""
for fh in self.image_list:
if value in fh.value_of(key):
return fh.load_source_file()
return None
class BaseImageProcessor(ImageWrapper):
process_dict = None
def __init__(
self,
file_path: str,
options: ArgWrapper = None,
database=None,
scale_factor=1,
) -> None:
super().__init__(file_path, database)
if options is None:
self._options = {}
else:
self._options = dict(options.__dict__)
self.target_database = database
self.scale_factor = scale_factor
self._source_image = None
self._current_image = None
self.mask = None
self.lock = False
self.image_list = []
self.forced_storage_images_list = []
self._rois_list = []
self._mosaic_data = None
self.data_output = {}
self.good_image = False
self.owner = None
self.msp_images_holder = None
self._built_channels = {}
self.csv_data_holder = self.init_csv_writer()
def init_data_holder(self):
self.csv_data_holder.clear()
self.csv_data_holder.update_csv_value("experiment", self.experiment)
self.csv_data_holder.update_csv_value("plant", self.plant)
self.csv_data_holder.update_csv_value("date_time", self.date_time)
self.csv_data_holder.update_csv_value("camera", self.camera)
self.csv_data_holder.update_csv_value("view_option", self.view_option)
def reset(self):
if self.lock:
return
self.init_data_holder()
self._rois_list = []
self.image_list = []
self.data_output = {}
self._mosaic_data = None
self.store_mosaic = "none"
self._current_image = self.source_image
def init_csv_writer(self):
"""Creates a csv writer with the variables specified in the class
child classes should override this method
:return: Csv writer
"""
return ipc.AbstractCsvWriter()
@staticmethod
def can_process(dict_data: dict) -> bool:
"""
Checks if the class can process the image
:param dict_data: Dictionnary containing filter data
:return: True if current class can process data
"""
return False
def load_source_image(self, store_source=False):
"""
Loads source image and applies corrections if needed
:param store_source: if true image will be stores in image_list
:return:numpy array -- Fixed source image
"""
src_img = self.file_handler.load_source_file()
self.good_image = src_img is not None
if self.good_image:
src_img = self._fix_source_image(src_img)
if self.scale_factor != 1:
src_img = ipc.resize_image(
src_img=src_img,
width=round(src_img.shape[1] * self.scale_factor),
height=round(src_img.shape[0] * self.scale_factor),
keep_aspect_ratio=False,
output_as_bgr=False,
)
if store_source:
self.store_image(src_img, "source")
else:
logger.error("Unable to load source image")
return src_img
def retrieve_msp_images(self):
"""On first call builds the wrappers corresponding to MSP images linked to observation
:return: Number of MSP images available
"""
if self.msp_images_holder is None:
self.msp_images_holder = ImageListHolder(
self.file_handler.linked_images,
self.target_database,
)
if self.msp_images_holder is None:
return 0
else:
return len(self.msp_images_holder)
@staticmethod
def draw_text(
img: Any,
text: str,
fnt_color: tuple = ipc.C_RED,
background_color: Union[None, tuple] = None,
) -> None:
"""Draw text into img, always draws on bottom left portion of the image
Modifies source image
:param img: target image
:param text: text
"""
fnt_face = cv2.FONT_HERSHEY_DUPLEX
fnt_scale = img.shape[0] / 1000
fnt_thickness = max(round(img.shape[0] / 1080), 1)
y = img.shape[0] - 20
for line in reversed(list(text.split("\n"))):
text_size, _ = cv2.getTextSize(line, fnt_face, fnt_scale, fnt_thickness)
if background_color is not None:
cv2.rectangle(
img,
(10, y - text_size[1] - 4),
(text_size[0], y + 4),
background_color,
-1,
)
cv2.putText(
img,
line,
(10, y),
fnt_face,
fnt_scale,
fnt_color,
fnt_thickness,
cv2.LINE_AA,
)
y -= text_size[1] + 8
def draw_image(self, **kwargs):
"""Build pseudo color image
Keyword Arguments:
* normalize_before: Normalize channel
* src_image: Source image
* channel: Channel to transform into pseudo color
* src_mask: Mask
* background: Background selection either 'img' or color tuple
* color_map: color map used
* roi: ignore everything outside ROI
* contour_thickness
* hull_thickness
* straight_bounding_rec_thickness
* enclosing_circle_thickness
* centroid_width
* height_thickness
* width_thickness
:return: drawn image
"""
src = kwargs.get("src_image", self.current_image)
mask = kwargs.get("src_mask", self.mask)
obj = kwargs.get("objects", None)
channel = kwargs.get("channel", "l")
background = kwargs.get("background", "source")
if background == "color":
background = kwargs.get("bcg_color", ipc.C_BLACK)
foreground = kwargs.get("foreground", "source")
if foreground == "color":
foreground = kwargs.get("fore_color", ipc.C_WHITE)
bck_grd_luma = kwargs.get("bck_grd_luma", 100)
normalize_before = bool(kwargs.get("normalize_before", False))
color_map = kwargs.get("color_map", ipc.DEFAULT_COLOR_MAP)
if isinstance(color_map, str):
_, color_map = color_map.split("_")
color_map = int(color_map)
roi = kwargs.get("roi", None)
contour_thickness = kwargs.get("contour_thickness", 0)
hull_thickness = kwargs.get("hull_thickness", 0)
bounding_rec_thickness = kwargs.get("bounding_rec_thickness", 0)
straight_bounding_rec_thickness = kwargs.get("straight_bounding_rec_thickness", 0)
enclosing_circle_thickness = kwargs.get("enclosing_circle_thickness", 0)
centroid_width = kwargs.get("centroid_width", 0)
centroid_line_width = kwargs.get("centroid_line_width", 4)
height_thickness = kwargs.get("height_thickness", 0)
width_thickness = kwargs.get("width_thickness", 0)
# Apply roi to mask
if (roi is not None) and (mask is not None):
mask_ = roi.keep(mask)
elif mask is not None:
mask_ = mask.copy()
else:
mask_ = None
fnt = (cv2.FONT_HERSHEY_SIMPLEX, 0.6)
fnt_scale = src.shape[0] / 1000
fnt_thickness = max(round(src.shape[1] / 1080) * 2, 1)
# Build foreground
if len(src.shape) == 2 or (len(src.shape) == 3 and src.shape[2] == 1):
foreground_img = np.dstack((src, src, src))
elif isinstance(foreground, tuple):
foreground_img = np.full(src.shape, foreground, np.uint8)
elif foreground == "source":
foreground_img = src.copy()
elif foreground == "false_colour":
if isinstance(channel, str):
c = self.get_channel(src, channel)
else:
c = channel.copy()
if mask_ is not None:
c = cv2.bitwise_and(c, c, mask=mask_)
if normalize_before:
c = cv2.equalizeHist(c)
foreground_img = cv2.applyColorMap(c, color_map)
elif foreground == "bw":
foreground_img = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
foreground_img = np.dstack((foreground_img, foreground_img, foreground_img))
elif isinstance(foreground, tuple):
foreground_img = np.full(src.shape, foreground, np.uint8)
elif isinstance(foreground, str):
foreground_img = np.full(src.shape, ipc.all_colors_dict[foreground], np.uint8)
else:
logger.error(f"Unknown foreground {background}")
return np.full(src.shape, ipc.C_FUCHSIA, np.uint8)
if mask_ is None:
img = foreground_img.copy()
else:
# Build background
if background == "white":
background_img = np.full(foreground_img.shape, ipc.C_WHITE, np.uint8)
elif background == "black":
background_img = np.full(foreground_img.shape, ipc.C_BLACK, np.uint8)
elif background == "silver":
background_img = np.full(foreground_img.shape, ipc.C_SILVER, np.uint8)
elif background == "bw":
background_img = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
background_img = np.dstack(
(background_img, background_img, background_img)
)
elif background == "source":
if len(src.shape) == 2 or (len(src.shape) == 3 and src.shape[2] == 1):
background_img = np.dstack((src, src, src))
else:
background_img = np.copy(src)
elif isinstance(background, tuple):
if len(background) == 3:
background_img = np.full(foreground_img.shape, background, np.uint8)
elif len(background) == 1:
background_img = np.full(
foreground_img.shape,
(background, background, background),
np.uint8,
)
else:
logger.error(f"Unknown color: {background}")
return np.full(foreground_img.shape, ipc.C_FUCHSIA, np.uint8)
else:
logger.error(f"Unknown background {background}")
return np.full(foreground_img.shape, ipc.C_FUCHSIA, np.uint8)
if bck_grd_luma != 100:
bck_grd_luma /= 100
lum, a, b = cv2.split(cv2.cvtColor(background_img, cv2.COLOR_BGR2LAB))
lum = (lum * bck_grd_luma).astype(np.uint)
lum[lum >= 255] = 255
lum = lum.astype(np.uint8)
background_img = cv2.merge((lum, a, b))
background_img = cv2.cvtColor(background_img, cv2.COLOR_LAB2BGR)
# Merge foreground & background
foreground_img = cv2.bitwise_and(foreground_img, foreground_img, mask=mask_)
background_img = cv2.bitwise_and(
background_img, background_img, mask=255 - mask_
)
img = cv2.bitwise_or(foreground_img, background_img)
# Draw contour
if (np.count_nonzero(mask_) > 0) and (
(contour_thickness > 0)
or (hull_thickness > 0)
or (bounding_rec_thickness > 0)
or (straight_bounding_rec_thickness > 0)
or (enclosing_circle_thickness > 0)
or (centroid_width > 0)
or (height_thickness > 0)
or (width_thickness > 0)
):
if obj is None:
id_objects, obj_hierarchy = ipc.get_contours_and_hierarchy(
mask=mask_,
retrieve_mode=cv2.RETR_TREE,
method=cv2.CHAIN_APPROX_NONE,
)
obj, _ = self.object_composition(img, id_objects, obj_hierarchy)
if contour_thickness > 0:
cv2.drawContours(img, obj, -1, ipc.C_FUCHSIA, contour_thickness)
if hull_thickness > 0:
hull = cv2.convexHull(obj)
cv2.drawContours(img, [hull], 0, ipc.C_LIME, hull_thickness)
if bounding_rec_thickness > 0:
rect = cv2.minAreaRect(obj)
box = cv2.boxPoints(rect)
box = np.int0(box)
cv2.drawContours(img, [box], 0, ipc.C_RED, bounding_rec_thickness)
if straight_bounding_rec_thickness > 0:
x, y, w, h = cv2.boundingRect(obj)
cv2.rectangle(
img, (x, y), (x + w, y + h), ipc.C_PURPLE, bounding_rec_thickness
)
if enclosing_circle_thickness > 0:
(x, y), radius = cv2.minEnclosingCircle(obj)
center = (int(x), int(y))
radius = int(radius)
cv2.circle(
img, center, radius, ipc.C_YELLOW, enclosing_circle_thickness
)
if (
(centroid_width > 0)
or (height_thickness > 0)
or (width_thickness > 0)
):
moments = cv2.moments(mask_, binaryImage=True)
if moments["m00"] != 0:
cmx, cmy = (
moments["m10"] / moments["m00"],
moments["m01"] / moments["m00"],
)
x_, y_, width_, height_ = cv2.boundingRect(obj)
if height_thickness > 0:
cv2.line(
img,
(int(cmx), y_),
(int(cmx), y_ + height_),
ipc.C_CYAN,
height_thickness,
)
if width_thickness > 0:
cv2.line(
img,
(x_, int(cmy)),
(x_ + width_, int(cmy)),
ipc.C_CYAN,
width_thickness,
)
if centroid_width > 0:
cv2.circle(
img,
(int(cmx), int(cmy)),
centroid_width,
ipc.C_BLUE,
centroid_line_width,
)
if bool(kwargs.get("cy_num", False)) is True:
cv2.line(
img,
(int(cmx), 0),
(int(cmx), int(cmy)),
ipc.C_BLUE,
centroid_line_width,
)
cv2.putText(
img,
f"cy: {cmy:.2f}",
(int(cmx) + 5, int(cmy / 2)),
fnt[0],
fnt_scale,
ipc.C_BLUE,
fnt_thickness,
)
if roi is not None:
src_ = src.copy()
src_[roi.top : roi.bottom, roi.left : roi.right] = img[
roi.top : roi.bottom, roi.left : roi.right
]
return src_
else:
return img
def store_image(
self,
image: Any,
text: str,
rois: Any = (),
mosaic_list: list = None,
text_overlay: Any = False,
force_store: bool = False,
font_color: tuple = ipc.C_RED,
**kwargs,
) -> dict:
"""
Store image for debug or result
:param image: Source image
:param text: Image name, used as key
:param rois: Regions of interest, will be printed on image
:param mosaic_list: if present add image name to list
:param text_overlay: Text to be printed on top of stored image
:param force_store: Bypass storage options
:return: Dictionary containing stored image data
"""
if self.owner is not None:
target = self.owner
text = f"{self.view_option}_{text}"
else:
target = self
for dic in target.image_list:
if dic["name"].lower() == text:
target.image_list.remove(dic)
if (
(text and (target.store_images or (text.lower() == "mosaic")))
or force_store
or (text in self.forced_storage_images_list)
):
# Create dummy image if issue
if image is not None:
cp = image.copy()
else:
cp = np.full((100, 100, 3), ipc.C_FUCHSIA, np.uint8)
# Ensure image is 3D
if (rois or text_overlay) and (
len(cp.shape) == 2 or (len(cp.shape) == 3 and cp.shape[2] == 1)
):
cp = np.dstack((cp, cp, cp))
# Print ROIs if needed
if isinstance(rois, bool) and rois:
rois = self.rois_list
if rois:
for roi in rois:
cp = roi.draw_to(cp, line_width=2)
# Print text if needed
if isinstance(text_overlay, str):
self.draw_text(
img=cp,
text=text_overlay,
fnt_color=font_color,
)
elif text_overlay:
self.draw_text(
img=cp,
text=text.replace(", ", "\n"),
fnt_color=font_color,
)
new_dict = dict(name=text, image=cp, written=False)
target.image_list.append(new_dict)
if target.write_images == "plot":
target.plot_image(img_dict=new_dict, destroy_window=True)
if mosaic_list is not None and text:
mosaic_list.append(text)
return new_dict
else:
return dict()
def image_path_from_name(self, name: str):
"""Calculates target image saving path from name
:param name: name of the image in the dictionary cf. image_list
:return: destination file path
"""
image_dict = self.retrieve_image_dict(name)
if image_dict is not None:
return self.image_storage_path(image_dict)
else:
return ""
def image_storage_path(
self,
dic: dict,
index: str = "",
ext: str = "jpg",
is_force_output: bool = False,
is_force_fullname: bool = False,
) -> str:
"""returns path to which an image will be written
Arguments:
dic {dictionary} -- image info: 'mode', 'text', 'image'
Keyword Arguments:
index {str} -- image index to be printed as a prefix (default: {''})
ext {str} -- extension format (default: {'jpg'})
Returns:
str -- destination file path
"""
store_ = is_force_output or self.is_store_image(dic["name"])
if not store_:
return ""
if dic["name"] == "use_source_name":
return f"{self.dst_path}{self.name}.{ext}"
if is_force_fullname:
if index:
return f'{self.dst_path}{index}_{self.name}_{dic["name"]}.{ext}'
else:
return f'{self.dst_path}{self.name}_{dic["name"]}.{ext}'
else:
if self.is_plot_image(dic["name"]):
return ""
elif self.is_save_image(dic["name"]):
if dic["name"] == "mosaic":
tmp_path = "{}{}".format(self.dst_path, "mosaics")
tmp_path = os.path.join(tmp_path, "")
force_directories(tmp_path)
return "{}{}.jpg".format(tmp_path, self.name)
else:
tmp_path = f"{self.dst_path}{self.name}"
tmp_path = os.path.join(tmp_path, "")
force_directories(tmp_path)
return f'{tmp_path}{index}_{dic["name"]}.{ext}'
else:
return ""
def save_image(self, img: Any, idx: int = -1) -> None:
if idx >= 0:
str_idx = str(idx)
else:
str_idx = ""
tmp_path = self.image_storage_path(img, index=str_idx)
if tmp_path:
cv2.imwrite(tmp_path, img["image"])
img["written"] = True
def plot_image(self, img_dict: dict, destroy_window: bool = False) -> bool:
res = False
try:
cv2.imshow(
img_dict["name"],
ipc.resize_image(
img_dict["image"].copy(),
target_rect=RectangleRegion(left=0, width=800, top=0, height=600),
keep_aspect_ratio=True,
),
)
cv2.waitKey(0)
if destroy_window:
cv2.destroyAllWindows()
except Exception as e:
logger.exception(f'Unable to plot {img_dict["name"]}: "{repr(e)}"')
res = False
else:
res = True
finally:
return res
def print_image(self, img: Any, idx: int = -1) -> None:
"""
Print image according to options
:param img: numpy array
:param idx: int
:return:
"""
if img["written"] is not True:
if self.is_plot_image(img["name"]):
self.plot_image(img_dict=img)
elif self.is_save_image(img["name"]):
self.save_image(img=img, idx=idx)
def retrieve_image_dict(self, dict_name: str):
"""Retrieve image dictionary from the name key
:rtype: bool, dict
:param dict_name: key
:return: success, image dictionary
"""
if dict_name.lower() == "":
return None
else:
for dic in self.image_list:
if dic["name"].lower() == dict_name.lower():
return dic
if dict_name.lower() == "source":
return self.store_image(self.source_image, "source")
if dict_name.lower() == "mask":
return self.store_image(self.mask, "mask")
return None
def print_mosaic(self, padding: 2):
if (self.store_mosaic.lower() != "none") or (self.write_mosaic.lower() != "none"):
if self._mosaic_data is None:
if self.store_mosaic.lower() == "debug":
self._mosaic_data = np.array(
["source", "img_wth_tagged_cnt", "shapes"]
)
elif self.store_mosaic.lower() == "result":
img_lst = ["!n", "!n", "!n", "!n"]
available_images = [dic["name"] for dic in self.image_list]
if "true_source_image" in available_images:
img_lst[0] = "true_source_image"
else:
img_lst[0] = "source"
if "mask" in available_images:
img_lst[1] = "mask"
if "pseudo_on" in available_images:
img_lst[2] = "pseudo_on"
if "shapes" in available_images:
img_lst[3] = "shapes"
for img_name in reversed(available_images):
if img_lst.count("!n") == 0:
break
if not (img_name in img_lst) and (img_name != "histogram"):
try:
idx = len(img_lst) - 1 - img_lst[::-1].index("!n")
except ValueError as _:
break
img_lst[idx] = img_name
self._mosaic_data = np.array(
[[img_lst[0], img_lst[1]], [img_lst[2], img_lst[3]]]
)
else:
raise NotImplementedError
try:
canvas = self.build_mosaic(padding=padding)
mosaic_ = self.store_image(canvas, "mosaic")
self.print_image(mosaic_)
except Exception as e:
# Unsupported format detected
logger.exception(
'Exception: "{}" - Image: "{}", unsupported mosaic'.format(
repr(e), str(self)
)
)
def print_images(self):
"""Prints images to disc according to options and selection
Keyword Arguments:
selection {list} -- List of image names to be printed (default: {[]})
"""
if self.write_images == "print":
for i, img in enumerate(self.image_list):
if img["written"] is True:
continue
self.print_image(img, i + 1)
self.print_mosaic()
def avg_brightness_contrast(
self, img: Any = None, mode: str = "std", mask=None
) -> tuple:
"""Calculates average brightness using one of 3 available methods
* std='standard, objective'
* p1='perceived option 1
* p2='perceived option 2, slower to calculate
:param mask:
:param img:
:param mode: std, p1 or p2
:return: mean, std_dev
"""
if img is None:
img = self.current_image
b, g, r = cv2.split(img)
if mode == "std":
c = r * 0.2126 + g * 0.7152 + b * 0.0722
elif mode == "p1":
c = r * 0.299 + g * 0.587 + b * 0.114
elif mode == "p2":
c = np.sqrt(
0.241 * np.power(r.astype(np.float), 2)
+ 0.691 * np.power(g.astype(np.float), 2)
+ 0.068 * np.power(b.astype(np.float), 2)
)
else:
logger.error("Unknown average calculation mode")
return 0, 0
if mask is None:
tmp_tuple = cv2.meanStdDev(c.reshape(c.shape[1] * c.shape[0]))
else:
tmp_tuple = cv2.meanStdDev(
c.reshape(c.shape[1] * c.shape[0]),
mask=mask.reshape(mask.shape[1] * mask.shape[0]),
)
return tmp_tuple[0][0][0], tmp_tuple[1][0][0]
def object_composition(self, img: Any, contours: Any, hierarchy: Any):
"""From PlantCV: Groups objects into a single object, usually done after object filtering.
Inputs:
contours = object list
Returns:
group = grouped contours list
mask = image mask
:param img: numpy array
:param contours: list
:param hierarchy: list
:return group: list
:return mask: numpy array
"""
ori_img = np.copy(img)
if len(ori_img.shape) == 2:
ori_img = np.dstack((ori_img, ori_img, ori_img))
mask = np.zeros_like(a=ori_img, dtype=np.uint8)
else:
mask = np.zeros_like(a=ori_img[:, :, 0], dtype=np.uint8)
stack = np.zeros((len(contours), 1))
for c, cnt in enumerate(contours):
# if hierarchy[0][c][3] == -1:
if hierarchy[0][c][2] == -1 and hierarchy[0][c][3] > -1:
stack[c] = 0
else:
stack[c] = 1
ids = np.where(stack == 1)[0]
if len(ids) > 0:
group = np.vstack([contours[i] for i in ids])
cv2.drawContours(mask, contours, -1, 255, -1, hierarchy=hierarchy)
if self.store_images:
dbg_img = self.draw_image(
src_image=ori_img, src_mask=mask, background="bw", foreground="source"
)
cv2.drawContours(dbg_img, group, -1, (255, 0, 0), 6)
for cnt in contours:
cv2.drawContours(dbg_img, cnt, -1, (255, 0, 255), 4)
self.store_image(dbg_img, "objcomp")
return group, mask
else:
logger.error(f"Warning: {repr(self.name)} Invalid contour.")
return None, None
@time_method
def analyze_object(self, img: Any, mask: Any):
"""Outputs numeric properties for an input object (contour or grouped contours).
Inputs:
img = image object (most likely the original), color(RGB)
obj = single or grouped contour object
mask = binary image to use as mask for moments analysis
debug = None, print, or plot. Print = save to file, Plot = print to screen.
Returns:
shape_header = shape data table headers
shape_data = shape data table values
:param img: numpy array
:param obj: list
:param mask: numpy array
:return:
"""
obj, mask = self.prepare_analysis(
self.draw_image(src_mask=mask, background="silver", foreground="source"), mask
)
# Valid objects can only be analyzed if they have >= 5 vertices
if len(obj) < 5:
return None, None, None
ori_img = np.copy(img)
hull = cv2.convexHull(obj)
m = cv2.moments(mask, binaryImage=True)
area = m["m00"]
if area:
# x and y position (bottom left?) and extent x (width) and extent y (height)
x, y, width, height = cv2.boundingRect(obj)
# Centroid (center of mass x, center of mass y)
cmx, cmy = (m["m10"] / m["m00"], m["m01"] / m["m00"])
# Store Shape Data
self.csv_data_holder.update_csv_value("area", area)
if self.csv_data_holder.has_csv_key("centroid"):
self.csv_data_holder.update_csv_value("centroid_x", cmx, force_pair=True)
self.csv_data_holder.update_csv_value("centroid_y", cmy, force_pair=True)
self.csv_data_holder.data_list.pop("centroid", None)
hull_area = cv2.contourArea(hull)
self.csv_data_holder.update_csv_value("hull_area", hull_area)
self.csv_data_holder.update_csv_value("shape_solidity", area / hull_area)
x, y, w, h = cv2.boundingRect(obj)
self.csv_data_holder.update_csv_value("shape_extend", float(area) / (w * h))
if self.csv_data_holder.has_csv_key("straight_bounding_rectangle"):
self.csv_data_holder.update_csv_value(
"straight_bounding_rectangle_left", x, force_pair=True
)
self.csv_data_holder.update_csv_value(
"straight_bounding_rectangle_width", w, force_pair=True
)
self.csv_data_holder.update_csv_value(
"straight_bounding_rectangle_top", y, force_pair=True
)
self.csv_data_holder.update_csv_value(
"straight_bounding_rectangle_height", h, force_pair=True
)
self.csv_data_holder.data_list.pop("straight_bounding_rectangle", None)
straight_bounding_rec_thickness = 4
else:
straight_bounding_rec_thickness = 0
if self.csv_data_holder.has_csv_key("rotated_bounding_rectangle"):
(x, y), (w, h), r = cv2.minAreaRect(obj)
wl = max(w, h)
hl = min(w, h)
self.csv_data_holder.update_csv_value(
key="rotated_bounding_rectangle_cx", value=x, force_pair=True
)
self.csv_data_holder.update_csv_value(
key="rotated_bounding_rectangle_cy", value=y, force_pair=True
)
self.csv_data_holder.update_csv_value(
key="rotated_bounding_rectangle_width", value=wl, force_pair=True
)
self.csv_data_holder.update_csv_value(
key="rotated_bounding_rectangle_height", value=hl, force_pair=True
)
self.csv_data_holder.update_csv_value(
key="rotated_bounding_rectangle_rotation",
value=r + 180,
force_pair=True,
)
self.csv_data_holder.data_list.pop("rotated_bounding_rectangle", None)
bounding_rec_thickness = 4
else:
bounding_rec_thickness = 0
if self.csv_data_holder.has_csv_key("minimum_enclosing_circle"):
(x, y), radius = cv2.minEnclosingCircle(obj)
self.csv_data_holder.update_csv_value(
"minimum_enclosing_circle_cx", x, force_pair=True
)
self.csv_data_holder.update_csv_value(
"minimum_enclosing_circle_cy", y, force_pair=True
)
self.csv_data_holder.update_csv_value(
"minimum_enclosing_circle_radius", radius, force_pair=True
)
self.csv_data_holder.data_list.pop("minimum_enclosing_circle", None)
enclosing_circle_thickness = 4
else:
enclosing_circle_thickness = 0
self.csv_data_holder.update_csv_value("shape_height", height)
if self.csv_data_holder.has_csv_key("width_data"):
mask_data = ipc.MaskData(mask)
_, _, _, min_, max_, avg_, std_ = mask_data.width_quantile_stats(
1, 0, tag=0
)
self.csv_data_holder.update_csv_value(
"shape_width", width, force_pair=True
)
self.csv_data_holder.update_csv_value(
"shape_width_min", min_, force_pair=True
)
self.csv_data_holder.update_csv_value(
"shape_width_max", max_, force_pair=True
)
self.csv_data_holder.update_csv_value(
"shape_width_avg", avg_, force_pair=True
)
self.csv_data_holder.update_csv_value(
"shape_width_std", std_, force_pair=True
)
self.csv_data_holder.data_list.pop("width_data", None)
if self.store_images:
# Start with the sure ones
self.store_image(
self.draw_image(
src_image=ori_img,
src_mask=mask,
objects=obj,
background="bw",
foreground="source",
contour_thickness=4,
hull_thickness=4
if self.csv_data_holder.has_csv_key("hull_area")
else 0,
width_thickness=4
if self.csv_data_holder.has_csv_key("shape_width")
else 0,
height_thickness=4
if self.csv_data_holder.has_csv_key("shape_height")
else 0,
centroid_width=10
if self.csv_data_holder.has_csv_key("centroid_x")
else 0,
),
"shapes",
)
self.store_image(
self.draw_image(
src_image=mask,
src_mask=mask,
objects=obj,
background="bw",
foreground="source",
contour_thickness=4,
hull_thickness=4
if self.csv_data_holder.has_csv_key("hull_area")
else 0,
width_thickness=4
if self.csv_data_holder.has_csv_key("shape_width")
else 0,
height_thickness=4
if self.csv_data_holder.has_csv_key("shape_height")
else 0,
centroid_width=10
if self.csv_data_holder.has_csv_key("centroid_x")
else 0,
),
"shapes_on_mask",
)
# Add new ones
if (
enclosing_circle_thickness
+ bounding_rec_thickness
+ straight_bounding_rec_thickness
> 0
):
self.store_image(
self.draw_image(
src_image=ori_img,
src_mask=mask,
objects=obj,
background="bw",
foreground="source",
enclosing_circle_thickness=enclosing_circle_thickness,
bounding_rec_thickness=bounding_rec_thickness,
straight_bounding_rec_thickness=straight_bounding_rec_thickness,
),
"more_shapes",
)
self.store_image(
self.draw_image(
src_image=mask,
src_mask=mask,
objects=obj,
background="bw",
foreground="source",
enclosing_circle_thickness=enclosing_circle_thickness,
bounding_rec_thickness=bounding_rec_thickness,
straight_bounding_rec_thickness=straight_bounding_rec_thickness,
),
"more_shapes_on_mask",
)
# handle width quantiles
keys = [k for k in self.csv_data_holder.data_list]
for k in keys:
if "quantile_width" in k:
_, kind, n = k.split("_")
n = int(n)
if kind.lower() == "width":
msk_dt = ipc.MaskData(mask)
qtl_img = np.zeros_like(mask)
qtl_img = np.dstack((qtl_img, qtl_img, qtl_img))
for i in range(n):
(
total_,
hull_,
solidity_,
min_,
max_,
avg_,
std_,
) = msk_dt.width_quantile_stats(n, i, tag=i)
self.csv_data_holder.update_csv_value(
f"quantile_width_{i + 1}_{n}_area", total_, True
)
self.csv_data_holder.update_csv_value(
f"quantile_width_{i + 1}_{n}_hull", hull_, True
)
self.csv_data_holder.update_csv_value(
f"quantile_width_{i + 1}_{n}_solidity", solidity_, True
)
self.csv_data_holder.update_csv_value(
f"quantile_width_{i + 1}_{n}_min_{kind}", min_, True
)
self.csv_data_holder.update_csv_value(
f"quantile_width_{i + 1}_{n}_max_{kind}", max_, True
)
self.csv_data_holder.update_csv_value(
f"quantile_width_{i + 1}_{n}_avg_{kind}", avg_, True
)
self.csv_data_holder.update_csv_value(
f"quantile_width_{i + 1}_{n}_std_{kind}", std_, True
)
p_qt_msk = msk_dt.height_quantile_mask(
total=n, index=i, colour=int((i + 1) / (n + 1) * 255)
)
qtl_img = cv2.bitwise_or(
qtl_img,
np.dstack(
(np.zeros_like(mask), p_qt_msk, np.zeros_like(mask))
),
)
self.store_image(qtl_img, f"quantiles_width_{n}")
self.csv_data_holder.data_list.pop(k, None)
else:
pass
return True
@time_method
def analyze_bound(
self,
img: Any,
mask: Any,
line_position: int = -1,
pseudo_color_channel: str = " v",
):
"""User-input boundary line tool
Inputs:
img = image
mask = mask made from selected contours
line_position = position of boundary line (a value of 0 would draw the line through the bottom of the image)
:param pseudo_color_channel: str
:param mask: numpy array, mask made from selected contours
:param line_position: int
:return success: bool
"""
if (line_position < 0) or not self.csv_data_holder.has_csv_key("bound_data"):
self.csv_data_holder.data_list.pop("bound_data", None)
return True
self.csv_data_holder.data_list.pop("bound_data", None)
roi_top = RectangleRegion(
left=0, width=self.width, top=0, height=line_position, name="roi_top"
)
roi_bottom = RectangleRegion(
left=0,
width=self.width,
top=line_position,
height=self.height - line_position,
name="roi_bottom",
)
mask_top = self.crop_to_roi(img=mask, roi=roi_top)
mask_bottom = self.crop_to_roi(img=mask, roi=roi_bottom)
mask_data_top = ipc.MaskData(mask_top)
mask_data_bottom = ipc.MaskData(mask_bottom)
area_ = self.csv_data_holder.retrieve_csv_value("area")
if area_ is None:
mask_data = ipc.MaskData(mask)
area_ = mask_data.area
if area_:
try:
t_height = mask_data_top.mask.shape[0] - mask_data_top.top_index
b_height = mask_data_bottom.height
self.csv_data_holder.update_csv_value(
"above_bound_height", t_height, force_pair=True
)
self.csv_data_holder.update_csv_value(
"above_bound_area", mask_data_top.area, force_pair=True
)
self.csv_data_holder.update_csv_value(
"above_bound_percent_area",
mask_data_top.area / area_ * 100,
force_pair=True,
)
self.csv_data_holder.update_csv_value(
"below_bound_height", b_height, force_pair=True
)
self.csv_data_holder.update_csv_value(
"below_bound_area", mask_data_bottom.area, force_pair=True
)
self.csv_data_holder.update_csv_value(
"below_bound_percent_area",
mask_data_bottom.area / area_ * 100,
force_pair=True,
)
self.csv_data_holder.update_csv_value(
"shape_height", t_height + b_height, force_pair=True
)
if self.store_images:
c = self.get_channel(src_img=img, channel=pseudo_color_channel)
background_img = np.dstack((c, c, c))
p_img = self.draw_image(
src_image=background_img,
channel=pseudo_color_channel,
src_mask=mask,
foreground="false_colour",
background="source",
normalize_before=True,
color_map=cv2.COLORMAP_SUMMER,
roi=roi_top,
centroid_width=10,
height_thickness=4,
width_thickness=4,
)
p_img = self.draw_image(
src_image=p_img,
channel=pseudo_color_channel,
src_mask=mask,
foreground="false_colour",
background="source",
normalize_before=False,
color_map=cv2.COLORMAP_HOT,
roi=roi_bottom,
centroid_width=10,
height_thickness=4,
width_thickness=4,
)
cv2.line(
p_img,
(0, line_position),
(self.width, line_position),
ipc.C_RED,
3,
)
self.store_image(p_img, "bounds")
except Exception as e:
logger.exception(f'Failed to analyse bounds "{repr(e)}"')
return False
else:
return True
else:
return False
@staticmethod
def apply_mask(img: Any, mask: Any, background_color: Any):
"""
Apply white image mask to image with a selected background color
Inputs:
* img = image object, color(RGB)
* mask = image object, binary (black background with white object)
* background_color = color tuple or white or black
Returns:
masked_img = masked image
:param img: numpy array
:param mask: numpy array
:param background_color: tuple or string
:return masked_img: numpy array
"""
if background_color.lower() == "white":
background_color = (255, 255, 255)
elif background_color.lower() == "black":
background_color = (0, 0, 0)
rem_img = cv2.bitwise_and(img, img, mask=mask)
background = np.full(img.shape, background_color, np.uint8)
background = cv2.bitwise_and(background, background, mask=255 - mask)
return cv2.bitwise_or(background, rem_img)
def analyse_chlorophyll(self, img: Any, mask: Any):
"""
Extract chlorophyll data
"""
if self.csv_data_holder.has_csv_key(
"chlorophyll_mean"
) or self.csv_data_holder.has_csv_key("chlorophyll_std_dev"):
try:
b, g, r = cv2.split(cv2.bitwise_and(img, img, mask=mask))
c = np.exp(
(-0.0280 * r * 1.04938271604938)
+ (0.0190 * g * 1.04938271604938)
+ (-0.0030 * b * 1.04115226337449)
+ 5.780
)
if self.store_images:
calc_img = cv2.bitwise_and(c, c, mask=mask)
calc_img = (
(calc_img - calc_img.min())
/ (calc_img.max() - calc_img.min())
* 255
).astype(np.uint8)
pseudo = self.draw_image(
src_image=img,
channel=calc_img,
background="source",
foreground="false_colour",
color_map=cv2.COLORMAP_RAINBOW,
)
self.store_image(pseudo, "pseudo_chlorophyll_on_img")
self.store_image(calc_img, "chlorophyll_calculated")
tmp_tuple = cv2.meanStdDev(
c.reshape(c.shape[1] * c.shape[0]),
mask=mask.reshape(mask.shape[1] * mask.shape[0]),
)
self.csv_data_holder.update_csv_value(
"chlorophyll_mean", tmp_tuple[0][0][0]
)
self.csv_data_holder.update_csv_value(
"chlorophyll_std_dev", tmp_tuple[1][0][0]
)
except Exception as e:
return False
else:
return True
else:
return True
@time_method
def analyze_color(
self,
img: Any,
mask: Any,
pseudo_color_channel: str = "v",
pseudo_color_map: int = 2,
pseudo_bkg: str = "bw",
):
"""Analyze the color properties of an image object
Inputs:
img = image
mask = mask made from selected contours
debug = None, print, or plot. Print = save to file, Plot = print to screen.
hist_plot_type = 'None', 'all', 'rgb','lab' or 'hsv'
color_slice_type = 'None', 'rgb', 'hsv' or 'lab'
pseudo_channel = 'None', 'l', 'm' (green-magenta), 'y' (blue-yellow), h','s', or 'v',
creates pseudo colored image based on the specified channel
pseudo_bkg = 'img' => channel image,
'white' => white background image,
'both' => both img and white options
:param pseudo_color_map:
:param img: numpy array
:param mask: numpy array
:param pseudo_color_channel: str
:param pseudo_bkg: str
"""
if not (
self.csv_data_holder.has_csv_key("color_std_dev")
or self.csv_data_holder.has_csv_key("color_mean")
):
return True
masked = cv2.bitwise_and(img, img, mask=mask)
channel_data = {}
for c in self.file_handler.channels_data:
if c[0] == "chla":
continue
channel_data[c[1]] = dict(
color_space=c[0],
channel_name=c[1],
data=self.get_channel(src_img=masked, channel=c[1]),
graph_color=ipc.channel_color(c[1]),
)
self.csv_data_holder.update_csv_value("hist_bins", f"{256}")
for k, v in channel_data.items():
if v["data"] is None:
logger.warning(f"Missing channel {ipc.get_hr_channel_name(k)}")
continue
tmp_tuple = cv2.meanStdDev(
src=v["data"].reshape(v["data"].shape[1] * v["data"].shape[0]),
mask=mask.reshape(mask.shape[1] * mask.shape[0]),
)
v["hist"] = cv2.calcHist([v["data"]], [0], mask, [256], [0, (256 - 1)])
seed_ = f'{v["color_space"]}_{k}'
self.csv_data_holder.update_csv_value(
key=f"{seed_}_std_dev",
value=tmp_tuple[1][0][0],
force_pair=self.csv_data_holder.has_csv_key("color_std_dev"),
)
self.csv_data_holder.update_csv_value(
key=f"{seed_}_mean",
value=tmp_tuple[0][0][0],
force_pair=self.csv_data_holder.has_csv_key("color_mean"),
)
# Remove consumed keys
if self.csv_data_holder.has_csv_key("color_std_dev"):
self.csv_data_holder.data_list.pop("color_std_dev", None)
if self.csv_data_holder.has_csv_key("color_mean"):
self.csv_data_holder.data_list.pop("color_mean", None)
# Create Histogram Plot
if self.store_images:
fig = plt.figure(figsize=(10, 10), dpi=100)
for k, v in channel_data.items():
if v["data"] is None:
continue
plt.plot(v["hist"], label=v["channel_name"])
plt.xlim([0, 256 - 1])
plt.legend()
if self.write_images != "print":
fig.canvas.draw()
# Now we can save it to a numpy array.
data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep="")
data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
self.store_image(data, "histogram")
elif self.write_images != "plot":
plt.axis("off")
plt.title("histogram")
fig.tight_layout()
plt.show()
plt.clf()
plt.close()
pseudo_colour = self.draw_image(
src_image=img,
channel=pseudo_color_channel,
color_map=pseudo_color_map,
foreground="false_colour",
src_mask=mask,
background=pseudo_bkg,
)
self.store_image(pseudo_colour, "pseudo_on")
# handle color quantiles
keys = [k for k in self.csv_data_holder.data_list]
for k in keys:
if "quantile_color" in k:
*_, n = k.split("_")
n = int(n)
for c, v in channel_data.items():
if v["data"] is None:
logger.warning(
f'Missing channel {v["color_space"]}, {v["channel_name"]}'
)
continue
seed_ = f'{v["color_space"]}_{c}'
hist = cv2.calcHist([v["data"]], [0], mask, [n], [0, (256 - 1)])
total_pixels = | np.sum(hist) | numpy.sum |
#!venv/bin/python
import matplotlib
matplotlib.use("tkAgg", warn=False)
import tkinter as tk
import matplotlib.pyplot as plt
import matplotlib.backends.backend_tkagg as tkagg
import src.parameters
import src.io
import src.ions
import src.aggregates
import src.peptides
import pandas as pd
import numpy as np
import scipy
class GUI(object):
def __init__(self, dataset):
self.dataset = dataset
self.root = tk.Tk()
self.root.geometry("1500x800")
self.root.winfo_toplevel().title("Ion-network Browser")
self.root_frame = tk.Frame(self.root, bd=1, relief="raised")
self.root_frame.pack(fill="both", expand=1)
self.__initOptionsFrame()
self.__initAggregatesFrame()
self.__initIonsFrame()
self.refresh()
self.start()
def start(self):
self.root.mainloop()
def __initOptionsFrame(self):
self.options_frame = tk.Frame(
self.root_frame,
bd=1,
relief="raised"
)
self.options_frame.pack(
side="left",
fill="x"
)
self.options = {}
self.addLabelOption()
self.addAxisOption()
# self.addViewTypeOption()
self.addShowEdgesOption()
self.addMinimumSignalOption()
self.addMaximumSignalOption()
self.addFDROption()
self.addSelectAllVisibleOption()
self.addUnselectAllVisibleOption()
self.addExpandNeighborOption()
self.addRefreshOption()
for option in self.options.values():
option.pack(anchor="w", fill="x", expand=1)
def addViewTypeOption(self):
self.options["View type"] = tk.Frame(
self.options_frame,
bd=1,
relief="raised"
)
tk.Label(
self.options["View type"],
text="View type",
).pack(anchor="w")
view_types = [
"Aggregates"
] + [
name.split("/")[-1][:-4] for name in self.dataset.parameters["APEX_FILE_NAMES"]
]
self.view_type = tk.IntVar()
self.view_type.set(-1)
for view_index, view_type in enumerate(view_types):
tk.Radiobutton(
self.options["View type"],
text=view_type,
value=view_index - 1,
variable=self.view_type,
command=self.refresh
).pack(anchor="w")
def addRefreshOption(self):
self.options["Refresh"] = tk.Button(
self.options_frame,
text="Refresh",
command=self.refresh,
anchor="w"
)
def addSelectAllVisibleOption(self):
def onclick():
self.dataset.selectAllVisible()
self.dataset.updateLabelSelection(self)
self.dataset.plotSelectedNodes(self)
self.dataset.plotIons(self)
self.refreshAggregateCanvas()
self.refreshIonCanvas()
self.options["Select all visible nodes"] = tk.Button(
self.options_frame,
text="Select all visible nodes",
command=onclick,
anchor="w"
)
def addUnselectAllVisibleOption(self):
def onclick():
self.dataset.unselectAllVisible()
self.dataset.updateLabelSelection(self)
self.dataset.plotSelectedNodes(self)
self.dataset.plotIons(self)
self.refreshAggregateCanvas()
self.refreshIonCanvas()
self.options["Unselect all visible nodes"] = tk.Button(
self.options_frame,
text="Unselect all visible nodes",
command=onclick,
anchor="w"
)
def addExpandNeighborOption(self):
def onclick():
self.dataset.selectVisibleNeighbors()
self.dataset.updateLabelSelection(self)
self.dataset.plotSelectedNodes(self)
self.dataset.plotIons(self)
self.refreshAggregateCanvas()
self.refreshIonCanvas()
self.options["Expand neighbors"] = tk.Button(
self.options_frame,
text="Expand neighbors",
anchor="w",
command=onclick
)
def addShowEdgesOption(self):
def onclick():
self.dataset.plotEdges(self)
self.refreshAggregateCanvas()
self.show_edges = tk.IntVar()
self.options["Show edges"] = tk.Checkbutton(
self.options_frame,
text="Show edges",
variable=self.show_edges,
anchor="w",
command=onclick
)
def addLabelOption(self):
self.options["Label type"] = tk.Frame(
self.options_frame,
bd=1,
relief="raised"
)
tk.Label(
self.options["Label type"],
text="Label type",
).pack(anchor="w")
label_types = [
"None",
"Peptide",
"Protein",
"m/z",
"rt",
"dt",
"Index",
]
self.label_type = tk.StringVar()
self.label_type.set(label_types[0])
def onclick():
self.dataset.updateLabelSelection(self)
# self.dataset.plotSelectedNodes(self)
# self.dataset.plotIons(self)
self.refreshAggregateCanvas()
self.refreshIonCanvas()
for label_type in label_types:
tk.Radiobutton(
self.options["Label type"],
text=label_type,
variable=self.label_type,
value=label_type,
command=onclick
).pack(anchor="w")
def addAxisOption(self):
self.options["Ion axis type"] = tk.Frame(
self.options_frame,
bd=1,
relief="raised"
)
tk.Label(
self.options["Ion axis type"],
text="Ion axis type",
).pack(anchor="w")
label_types = [
"Log intensity",
"rt",
"dt",
]
self.axis_type = tk.StringVar()
self.axis_type.set(label_types[0])
def onclick():
axis_types = {
"Log intensity": "CALIBRATED_INTENSITY",
"dt": "DT",
"rt": "RT",
}
axis_type = axis_types[self.getAxisType()]
axis_min_lim = np.min(self.dataset.ions[axis_type])
axis_max_lim = np.max(self.dataset.ions[axis_type])
if axis_type == "CALIBRATED_INTENSITY":
axis_min_lim = np.log2(axis_min_lim)
axis_max_lim = np.log2(axis_max_lim)
self.ion_ax.set_ylim(
axis_min_lim,
axis_max_lim,
)
self.ion_ax.set_ylabel(axis_type)
self.dataset.labelIons(self)
self.dataset.plotIons(self)
self.refreshIonCanvas()
for label_type in label_types:
tk.Radiobutton(
self.options["Ion axis type"],
text=label_type,
variable=self.axis_type,
value=label_type,
command=onclick
).pack(anchor="w")
def addFDROption(self):
self.options["Log FDR threshold"] = tk.Frame(
self.options_frame,
bd=1,
relief="raised"
)
tk.Label(
self.options["Log FDR threshold"],
text="Log FDR threshold",
).pack(anchor="w")
def onclick(*args):
label_type = self.getLabelType()
if (label_type == "Peptide") or (label_type == "Protein"):
self.dataset.updateLabelSelection(self)
self.refreshIonCanvas()
self.dataset.plotAnnotatedNodes(self)
self.refreshAggregateCanvas()
self.fdr_threshold_slider = tk.Scale(
self.options["Log FDR threshold"],
from_=-5,
resolution=0.1,
to=0,
orient="horizontal",
command=onclick
)
self.fdr_threshold_slider.set(-2)
self.fdr_threshold_slider.pack(anchor="w")
def addMinimumSignalOption(self):
self.options["Minimum signal"] = tk.Frame(
self.options_frame,
bd=1,
relief="raised"
)
tk.Label(
self.options["Minimum signal"],
text="Minimum signal",
).pack(anchor="w")
self.minimum_replicate_count_slider = tk.Scale(
self.options["Minimum signal"],
from_=self.dataset.parameters["SIGNAL_COUNT_THRESHOLD"],
to=self.dataset.parameters["SAMPLE_COUNT"],
orient="horizontal",
command=lambda arg: self.refresh()
)
self.minimum_replicate_count_slider.set(
self.dataset.parameters["SAMPLE_COUNT"]
)
self.minimum_replicate_count_slider.pack(anchor="w")
def addMaximumSignalOption(self):
self.options["Maximum signal"] = tk.Frame(
self.options_frame,
bd=1,
relief="raised"
)
tk.Label(
self.options["Maximum signal"],
text="Maximum signal",
).pack(anchor="w")
self.maximum_replicate_count_slider = tk.Scale(
self.options["Maximum signal"],
from_=self.dataset.parameters["SIGNAL_COUNT_THRESHOLD"],
to=self.dataset.parameters["SAMPLE_COUNT"],
orient="horizontal",
command=lambda arg: self.refresh()
)
self.maximum_replicate_count_slider.set(
self.dataset.parameters["SAMPLE_COUNT"]
)
self.maximum_replicate_count_slider.pack(anchor="w")
def __initAggregatesFrame(self):
self.aggregate_frame = tk.Frame(
self.root_frame,
bd=1,
relief="raised"
)
self.aggregate_frame.pack(
side="left",
fill="both",
expand=True
)
self.aggregate_fig = plt.Figure()
self.aggregate_ax = self.aggregate_fig.add_subplot(111)
self.aggregate_canvas = tkagg.FigureCanvasTkAgg(self.aggregate_fig, self.aggregate_frame)
self.aggregate_canvas.get_tk_widget().pack(
fill='both',
expand=True
)
self.aggregate_toolbar = tkagg.NavigationToolbar2Tk(
self.aggregate_canvas,
self.aggregate_frame
)
default_release = self.aggregate_toolbar.release
def release(event):
default_release(event)
self.refresh()
self.aggregate_toolbar.release = release
self.aggregate_ax.set_xlim(
[
np.min(self.dataset.anchors["RT"]),
np.max(self.dataset.anchors["RT"]),
]
)
self.aggregate_ax.set_ylim(
[
np.min(self.dataset.anchors["DT"]),
np.max(self.dataset.anchors["DT"]),
]
)
self.aggregate_ax.set_xlabel("RT")
self.aggregate_ax.set_ylabel("DT")
self.aggregate_ax.set_title("Aggregates")
def onclick(event):
if (event is None) or (not event.dblclick):
return
self.dataset.updateSelectedNodes(self, event)
self.dataset.plotSelectedNodes(self)
self.dataset.plotIons(self)
self.refreshAggregateCanvas()
self.refreshIonCanvas()
self.aggregate_canvas.mpl_disconnect(self.click_connection)
self.click_connection = self.aggregate_canvas.mpl_connect(
'button_press_event',
onclick
)
self.click_connection = self.aggregate_canvas.mpl_connect(
'button_press_event',
onclick
)
def __initIonsFrame(self):
self.ion_frame = tk.Frame(
self.root_frame,
bd=1,
relief="raised"
)
self.ion_frame.pack(
side="left",
fill="y",
)
self.ion_fig = plt.Figure()
self.ion_ax = self.ion_fig.add_subplot(111)
self.ion_canvas = tkagg.FigureCanvasTkAgg(self.ion_fig, self.ion_frame)
self.ion_toolbar = tkagg.NavigationToolbar2Tk(
self.ion_canvas,
self.ion_frame
)
self.ion_canvas.get_tk_widget().pack(
fill='both',
expand=True
)
self.getAxisType()
self.ion_ax.set_title("Ions")
def refresh(self):
self.dataset.updateVisibleNodes(self)
self.dataset.plotVisibleNodes(self)
self.dataset.plotAnnotatedNodes(self)
self.dataset.plotSelectedNodes(self)
self.dataset.plotEdges(self)
self.refreshAggregateCanvas()
self.dataset.plotIons(self)
self.refreshIonCanvas()
def refreshAggregateCanvas(self):
self.aggregate_canvas.draw()
self.aggregate_canvas.flush_events()
def refreshIonCanvas(self):
self.ion_canvas.draw()
self.ion_canvas.flush_events()
def getMinimumReplicateCount(self):
return self.minimum_replicate_count_slider.get()
def getMaximumReplicateCount(self):
return self.maximum_replicate_count_slider.get()
def getLabelType(self):
return self.label_type.get()
def getViewType(self):
try:
return self.view_type.get()
except AttributeError:
return -1
def getFDRThreshold(self):
return 10 ** self.fdr_threshold_slider.get()
def getAxisType(self):
return self.axis_type.get()
def getShowEdges(self):
return self.show_edges.get()
def getVisibleBoundaries(self):
dt_low, dt_high = self.aggregate_ax.get_ylim()
rt_low, rt_high = self.aggregate_ax.get_xlim()
return rt_low, rt_high, dt_low, dt_high
def dummyCommand(self, *args, **kwargs):
print(self.getMinimumReplicateCount())
print(self.getMaximumReplicateCount())
print(self.getLabelType())
print(self.getViewType())
print(self.getFDRThreshold())
print(self.getAxisType())
print(self.getShowEdges())
class Dataset(object):
def __init__(self, parameters, **kwargs):
if isinstance(parameters, str):
parameters = src.parameters.importParameterDictFromJSON(parameters)
self.parameters = parameters
self.log = src.io.Log(self.parameters["LOG_FILE_NAME"][:-4] + "_browser.txt")
if "aggregates" in kwargs:
self.anchors = kwargs["aggregates"]
else:
self.anchors = src.io.loadArray("ANCHORS_FILE_NAME", self.parameters)
if "anchor_ions" in kwargs:
self.anchor_ions = kwargs["anchor_ions"]
else:
self.anchor_ions = src.io.loadMatrix(
"ANCHOR_IONS_FILE_NAME",
self.parameters,
)
if "ions" in kwargs:
self.ions = kwargs["ions"]
else:
self.ions = src.io.loadArray("IONS_FILE_NAME", self.parameters)
if "neighbors" in kwargs:
self.neighbors = kwargs["neighbors"]
else:
self.neighbors = src.io.loadMatrix(
"ANCHOR_NEIGHBORS_FILE_NAME",
self.parameters,
)
self.neighbors += self.neighbors.T
try:
if "anchor_peptide_score" in kwargs:
self.anchor_peptide_scores = kwargs["anchor_peptide_score"]
else:
self.anchor_peptide_scores = src.io.loadMatrix(
"ANCHOR_PEPTIDE_SCORES_FILE_NAME",
self.parameters,
)
if "anchor_peptide_match_counts" in kwargs:
self.anchor_peptide_match_counts = kwargs["anchor_peptide_match_counts"]
else:
self.anchor_peptide_match_counts = src.io.loadMatrix(
"ANCHOR_PEPTIDE_MATCH_COUNTS_FILE_NAME",
self.parameters,
)
self.percolated_annotations = pd.read_csv(
self.parameters["PERCOLATOR_TARGET_PIMS"],
delimiter="\t"
)
self.percolated_fdrs = self.percolated_annotations.values[:, 2]
self.percolated_anchors, self.percolated_peptides = self.anchor_peptide_match_counts.nonzero()
except FileNotFoundError:
self.anchor_peptide_scores = scipy.sparse.csr_matrix([])
self.anchor_peptide_match_counts = scipy.sparse.csr_matrix([])
self.percolated_annotations = pd.DataFrame()
self.percolated_fdrs = np.array([], dtype=np.int)
self.percolated_anchors = np.array([], dtype=np.int)
self.percolated_peptides = np.array([], dtype=np.int)
# self.proteins, self.total_protein_sequence, self.ptms, self.ptm_matrix = src.peptides.importProteinsAndPtms(
# self.parameters,
# self.log
# )
# self.peptides, self.peptide_index_matrix, self.digestion_matrix = src.peptides.digestProteins(
# self.proteins,
# self.total_protein_sequence,
# self.ptm_matrix,
# self.parameters,
# self.log
# )
database = src.peptides.loadDatabase(parameters["DATABASE_FILE_NAME"])
# base_mass_dict = database["base_mass_dict"]
self.proteins = database["proteins"]
self.total_protein_sequence = database["total_protein_sequence"]
# ptms = database["ptms"]
# ptm_matrix = database["ptm_matrix"]
self.peptides = database["peptides"]
self.peptide_index_matrix = database["peptide_index_matrix"]
# digestion_matrix = database["digestion_matrix"]
# peptide_masses = database["peptide_masses"]
# fragments = database["fragments"]
self.visible_nodes = np.array([], dtype=np.int)
self.selected_nodes = np.array([], dtype=np.bool)
self.node_labels = np.array([], dtype=np.bool)
def updateVisibleNodes(self, gui):
self.log.printMessage("Updating visible nodes")
previous_selection = self.visible_nodes[self.selected_nodes]
rt_low, rt_high, dt_low, dt_high = gui.getVisibleBoundaries()
selection = self.anchors["ION_COUNT"] >= gui.getMinimumReplicateCount()
selection &= self.anchors["ION_COUNT"] <= gui.getMaximumReplicateCount()
selection &= self.anchors["DT"] <= dt_high
selection &= self.anchors["DT"] >= dt_low
selection &= self.anchors["RT"] <= rt_high
selection &= self.anchors["RT"] >= rt_low
self.visible_nodes = | np.flatnonzero(selection) | numpy.flatnonzero |
# -*- coding: utf-8 -*-
import os
import argparse
import random
import numpy as np
from tqdm import tqdm
import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torch.autograd import Variable
from models.resnet12_2 import resnet12
from models.meta_part_inference_mini import ProtoComNet
from models.PredTrainHead import LinearClassifier, LinearRotateHead
from utils import set_gpu, Timer, count_accuracy, check_dir, log
import pickle
def one_hot(indices, depth):
"""
Returns a one-hot tensor.
This is a PyTorch equivalent of Tensorflow's tf.one_hot.
Parameters:
indices: a (n_batch, m) Tensor or (m) Tensor.
depth: a scalar. Represents the depth of the one hot dimension.
Returns: a (n_batch, m, depth) Tensor or (m, depth) Tensor.
"""
encoded_indicies = torch.zeros(indices.size() + torch.Size([depth])).cuda()
index = indices.view(indices.size()+torch.Size([1]))
encoded_indicies = encoded_indicies.scatter_(1,index,1)
return encoded_indicies
def get_model(options):
# Choose the embedding network
if options.network == 'ResNet':
network = resnet12().cuda()
network = torch.nn.DataParallel(network)
fea_dim = 512
else:
print ("Cannot recognize the network type")
assert(False)
propa_head = ProtoComNet(opt=options, in_dim=fea_dim).cuda()
# Choose the classification head
if opt.use_trainval == 'True':
n_classes=80
else:
n_classes=64
if options.pre_head == 'LinearNet':
pre_head = LinearClassifier(in_dim=fea_dim, n_classes=n_classes).cuda()
elif options.pre_head == 'LinearRotateNet':
pre_head = LinearRotateHead(in_dim=fea_dim, n_classes=n_classes).cuda()
else:
print("Cannot recognize the dataset type")
assert (False)
if options.phase == 'pretrain':
from models.classification_heads_orgin import ClassificationHead
else:
from models.classification_heads import ClassificationHead
# Choose the classification head
if options.head == 'CosineNet':
cls_head = ClassificationHead(base_learner='CosineNet').cuda()
elif options.head == 'FuseCosNet':
cls_head = ClassificationHead(base_learner='FuseCos').cuda()
else:
print ("Cannot recognize the dataset type")
assert(False)
return (network, propa_head, pre_head, cls_head)
def get_dataset(options):
# Choose the embedding network
if options.dataset == 'miniImageNet':
from data.mini_imagenet import MiniImageNet, FewShotDataloader, MiniImageNetPC
# dataset_trainval = MiniImageNet(phase='trainval')
if options.phase == 'savepart':
dataset_train = MiniImageNet(phase='train', do_not_use_random_transf=True)
elif options.phase == 'metainfer':
dataset_train = MiniImageNetPC(phase='train', shot=options.train_shot)
else:
dataset_train = MiniImageNet(phase='train')
dataset_val = MiniImageNet(phase='val')
dataset_test = MiniImageNet(phase='test')
data_loader = FewShotDataloader
else:
print ("Cannot recognize the dataset type")
assert(False)
return (dataset_train, dataset_val, dataset_test, data_loader)
def seed_torch(seed=21):
os.environ['PYTHONHASHSEED'] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
def pre_train(opt, dataset_train, dataset_val, dataset_test, data_loader):
data_loader_pre = torch.utils.data.DataLoader
# Dataloader of Gidaris & Komodakis (CVPR 2018)
if opt.use_trainval == 'True':
train_way = 80
dloader_train = data_loader_pre(
dataset=dataset_trainval,
batch_size=128,
shuffle=True,
num_workers=4
)
else:
train_way = 64
dloader_train = data_loader_pre(
dataset=dataset_train,
batch_size=128,
shuffle=True,
num_workers=4
)
dloader_val = data_loader(
dataset=dataset_val,
nKnovel=opt.test_way,
nKbase=0,
nExemplars=opt.val_shot, # num training examples per novel category
nTestNovel=opt.val_query * opt.test_way, # num test examples for all the novel categories
nTestBase=0, # num test examples for all the base categories
batch_size=1,
num_workers=0,
epoch_size=1 * opt.val_episode, # num of batches per epoch
)
set_gpu(opt.gpu)
check_dir('./experiments/')
check_dir(opt.save_path)
log_file_path = os.path.join(opt.save_path, "train_log.txt")
log(log_file_path, str(vars(opt)))
(embedding_net, propa_head, pre_head, cls_head) = get_model(opt)
print(list(dict(propa_head.named_parameters()).keys()))
optimizer = torch.optim.SGD([{'params': embedding_net.parameters()},
{'params': pre_head.parameters()}], lr=0.1, momentum=0.9, \
weight_decay=5e-4, nesterov=True)
lambda_epoch = lambda e: 1.0 if e < 60 else (0.1 if e < 80 else 0.01 if e < 90 else (0.001))
lr_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_epoch, last_epoch=-1)
max_val_acc = 0.0
max_test_acc = 0.0
timer = Timer()
x_entropy = torch.nn.CrossEntropyLoss()
for epoch in range(1, opt.num_epoch + 1):
# Train on the training split
lr_scheduler.step()
# Fetch the current epoch's learning rate
epoch_learning_rate = 0.1
for param_group in optimizer.param_groups:
epoch_learning_rate = param_group['lr']
log(log_file_path, 'Train Epoch: {}\tLearning Rate: {:.4f}'.format(
epoch, epoch_learning_rate))
_, _, _, _ = [x.train() for x in (embedding_net, propa_head, pre_head, cls_head)]
train_accuracies = []
train_losses = []
for i, batch in enumerate(tqdm(dloader_train), 1):
data, labels = [x.cuda() for x in batch]
if opt.pre_head == 'LinearNet' or opt.pre_head == 'CosineNet':
emb = embedding_net(data)
logit = pre_head(emb)
smoothed_one_hot = one_hot(labels.reshape(-1), train_way)
smoothed_one_hot = smoothed_one_hot * (1 - opt.eps) + (1 - smoothed_one_hot) * opt.eps / (train_way - 1)
log_prb = F.log_softmax(logit.reshape(-1, train_way), dim=1)
loss = -(smoothed_one_hot * log_prb).sum(dim=1)
loss = loss.mean()
acc = count_accuracy(logit.reshape(-1, train_way), labels.reshape(-1))
elif opt.pre_head == 'LinearRotateNet' or opt.pre_head == 'DistRotateNet':
x_ = []
y_ = []
a_ = []
for j in range(data.shape[0]):
x90 = data[j].transpose(2, 1).flip(1)
x180 = x90.transpose(2, 1).flip(1)
x270 = x180.transpose(2, 1).flip(1)
x_ += [data[j], x90, x180, x270]
y_ += [labels[j] for _ in range(4)]
a_ += [torch.tensor(0), torch.tensor(1), torch.tensor(2), torch.tensor(3)]
x_ = Variable(torch.stack(x_, 0)).cuda()
y_ = Variable(torch.stack(y_, 0)).cuda()
a_ = Variable(torch.stack(a_, 0)).cuda()
emb = embedding_net(x_)
# print(emb.shape)
logit = pre_head(emb, use_cls=True)
logit_rotate = pre_head(emb, use_cls=False)
smoothed_one_hot = one_hot(y_.reshape(-1), train_way)
smoothed_one_hot = smoothed_one_hot * (1 - opt.eps) + (1 - smoothed_one_hot) * opt.eps / (train_way - 1)
log_prb = F.log_softmax(logit.reshape(-1, train_way), dim=1)
loss = -(smoothed_one_hot * log_prb).sum(dim=1)
loss = loss.mean()
rloss = F.cross_entropy(input=logit_rotate, target=a_)
loss = 0.5 * loss + 0.5 * rloss
acc = count_accuracy(logit.reshape(-1, train_way), y_.reshape(-1))
else:
print("Cannot recognize the pre_head type")
assert (False)
train_accuracies.append(acc.item())
train_losses.append(loss.item())
if (i % 100 == 0):
train_acc_avg = np.mean(np.array(train_accuracies))
log(log_file_path, 'Train Epoch: {}\tBatch: [{}]\tLoss: {}\tAccuracy: {} % ({} %)'.format(
epoch, i, loss.item(), train_acc_avg, acc))
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Evaluate on the validation split
_, _, _, _ = [x.eval() for x in (embedding_net, propa_head, pre_head, cls_head)]
val_accuracies = []
val_losses = []
for i, batch in enumerate(tqdm(dloader_val(opt.seed)), 1):
data_support, labels_support, \
data_query, labels_query, _, _ = [
x.cuda() for x in batch]
test_n_support = opt.test_way * opt.val_shot
test_n_query = opt.test_way * opt.val_query
emb_support = embedding_net(data_support.reshape([-1] + list(data_support.shape[-3:])))
emb_support = emb_support.reshape(1, test_n_support, -1)
emb_query = embedding_net(data_query.reshape([-1] + list(data_query.shape[-3:])))
emb_query = emb_query.reshape(1, test_n_query, -1)
logit_query = cls_head(emb_query, emb_support, labels_support, opt.test_way, opt.val_shot)
loss = x_entropy(logit_query.reshape(-1, opt.test_way), labels_query.reshape(-1))
acc = count_accuracy(logit_query.reshape(-1, opt.test_way), labels_query.reshape(-1))
val_accuracies.append(acc.item())
val_losses.append(loss.item())
val_acc_avg = np.mean(np.array(val_accuracies))
val_acc_ci95 = 1.96 * np.std(np.array(val_accuracies)) / np.sqrt(opt.val_episode)
val_loss_avg = np.mean(np.array(val_losses))
if val_acc_avg > max_val_acc:
max_val_acc = val_acc_avg
torch.save({'embedding': embedding_net.state_dict(), 'propa_head': propa_head.state_dict(),
'pre_head': pre_head.state_dict(), 'cls_head': cls_head.state_dict()}, \
os.path.join(opt.save_path, 'best_pretrain_model.pth'))
log(log_file_path, 'Validation Epoch: {}\t\t\tLoss: {:.4f}\tAccuracy: {:.2f} ± {:.2f} % (Best)' \
.format(epoch, val_loss_avg, val_acc_avg, val_acc_ci95))
else:
log(log_file_path, 'Validation Epoch: {}\t\t\tLoss: {:.4f}\tAccuracy: {:.2f} ± {:.2f} %' \
.format(epoch, val_loss_avg, val_acc_avg, val_acc_ci95))
torch.save({'embedding': embedding_net.state_dict(), 'propa_head': propa_head.state_dict(),
'pre_head': pre_head.state_dict(), 'cls_head': cls_head.state_dict()} \
, os.path.join(opt.save_path, 'last_pretrain_epoch.pth'))
if epoch % opt.save_epoch == 0:
torch.save({'embedding': embedding_net.state_dict(), 'propa_head': propa_head.state_dict(),
'pre_head': pre_head.state_dict(), 'cls_head': cls_head.state_dict()} \
, os.path.join(opt.save_path, 'epoch_{}_pretrain.pth'.format(epoch)))
def part_prototype(opt, dataset_train, dataset_val, dataset_test, data_loader):
data_loader_pre = torch.utils.data.DataLoader
# Dataloader of Gidaris & Komodakis (CVPR 2018)
dloader_train = data_loader_pre(
dataset=dataset_train,
batch_size=1,
shuffle=False,
num_workers=0
)
set_gpu(opt.gpu)
check_dir('./experiments/')
check_dir(opt.save_path)
log_file_path = os.path.join(opt.save_path, "train_log.txt")
log(log_file_path, str(vars(opt)))
(embedding_net, propa_head, pre_head, cls_head) = get_model(opt)
# Load saved model checkpoints
saved_models = torch.load(os.path.join(opt.save_path, 'best_pretrain_model.pth'))
embedding_net.load_state_dict(saved_models['embedding'])
embedding_net.eval()
embs = []
for i, batch in enumerate(tqdm(dloader_train), 1):
data, labels = [x.cuda() for x in batch]
with torch.no_grad():
emb = embedding_net(data)
embs.append(emb)
embs = torch.cat(embs, dim=0)
with open('./data/mini_imagenet_part_prior_train.pickle', 'rb') as handle:
part_prior = pickle.load(handle)
train_class_name_file = './data/mini_imagenet_catname2label_train.pickle'
with open(train_class_name_file, 'rb') as handle:
catname2label_train = pickle.load(handle)
a = 1
attr_feature = {}
for attr_id in part_prior['attribute_id_class_dict'].keys():
if attr_id not in [part_prior['wnids2id'][wnid] for wnid in part_prior['all_wnids']]:
attr_im_id = []
for sel_class_id in list(set(part_prior['attribute_id_class_dict'][attr_id])):
if sel_class_id in [part_prior['wnids2id'][wnid] for wnid in part_prior['wnids_train']]:
sel_class = catname2label_train[part_prior['id2wnids'][sel_class_id]]
attr_im_id.extend(dataset_train.label2ind[sel_class])
attr_im = embs[attr_im_id, :]
mean = torch.mean(attr_im, dim=0).unsqueeze(dim=0)
std = torch.std(attr_im, dim=0).unsqueeze(dim=0)
attr_feature[attr_id] = {'mean': mean, 'std':std}
with open(os.path.join(opt.save_path, "mini_imagenet_metapart_feature.pickle"), 'wb') as handle:
pickle.dump(attr_feature, handle, protocol=pickle.HIGHEST_PROTOCOL)
class_feature = {}
for class_id in part_prior['class_attribute_id_dict'].keys():
if class_id in [part_prior['wnids2id'][wnid] for wnid in part_prior['wnids_train']]:
sel_class = catname2label_train[part_prior['id2wnids'][class_id]]
class_im = embs[dataset_train.label2ind[sel_class], :]
mean = torch.mean(class_im, dim=0).unsqueeze(dim=0)
std = torch.std(class_im, dim=0).unsqueeze(dim=0)
class_feature[sel_class] = {'mean': mean, 'std':std}
with open(os.path.join(opt.save_path, "mini_imagenet_class_feature.pickle"), 'wb') as handle:
pickle.dump(class_feature, handle, protocol=pickle.HIGHEST_PROTOCOL)
def meta_inference(opt, dataset_train, dataset_val, dataset_test, data_loader):
data_loader_pre = torch.utils.data.DataLoader
# Dataloader of Gidaris & Komodakis (CVPR 2018)
dloader_train = data_loader_pre(
dataset=dataset_train,
batch_size=128,
shuffle=True,
num_workers=0
)
dloader_val = data_loader(
dataset=dataset_val,
nKnovel=opt.test_way,
nKbase=0,
nExemplars=opt.val_shot, # num training examples per novel category
nTestNovel=opt.val_query * opt.test_way, # num test examples for all the novel categories
nTestBase=0, # num test examples for all the base categories
batch_size=1,
num_workers=0,
epoch_size=1 * opt.val_episode, # num of batches per epoch
)
set_gpu(opt.gpu)
check_dir('./experiments/')
check_dir(opt.save_path)
log_file_path = os.path.join(opt.save_path, "train_log.txt")
log(log_file_path, str(vars(opt)))
(embedding_net, propa_head, pre_head, cls_head) = get_model(opt)
# Load saved model checkpoints
saved_models = torch.load(os.path.join(opt.save_path, 'best_pretrain_model.pth'))
embedding_net.load_state_dict(saved_models['embedding'])
embedding_net.eval()
cls_head.eval()
optimizer = torch.optim.SGD([{'params': propa_head.parameters()}], lr=0.1, momentum=0.9, \
weight_decay=5e-4, nesterov=True)
lambda_epoch = lambda e: 1.0 if e < 15 else (0.1 if e < 40 else 0.01 if e < 80 else (0.001))
lr_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_epoch, last_epoch=-1)
train_losses = []
x_entropy = torch.nn.CrossEntropyLoss()
max_loss = 10e16
max_val_acc = 0
max_test_acc = 0
for epoch in range(0, opt.num_epoch + 1):
# Train on the training split
lr_scheduler.step()
# Fetch the current epoch's learning rate
epoch_learning_rate = 0.1
for param_group in optimizer.param_groups:
epoch_learning_rate = param_group['lr']
log(log_file_path, 'Train Epoch: {}\tLearning Rate: {:.4f}'.format(
epoch, epoch_learning_rate))
propa_head.train()
train_accuracies = []
for i, batch in enumerate(tqdm(dloader_train), 1):
data, labels = [x.cuda() for x in batch]
nb, ns, nc, nw, nh = data.shape
with torch.no_grad():
data = data.reshape(nb*ns, nc, nw, nh)
emb = embedding_net(data)
emb = emb.reshape(nb, ns, -1)
emb = emb.mean(dim=1)
proto, proto_true = propa_head(emb, labels)
loss = F.mse_loss(proto, proto_true)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_losses.append(loss.item())
if (i % 10 == 0):
train_loss_avg = np.mean(np.array(train_losses))
log(log_file_path, 'Train Epoch: {}\tBatch: [{}]\tLoss: {}({})'.format(
epoch, i, loss.item(), train_loss_avg))
# Evaluate on the validation split
_, _, _, _ = [x.eval() for x in (embedding_net, propa_head, pre_head, cls_head)]
val_accuracies = []
val_losses = []
for i, batch in enumerate(tqdm(dloader_val(opt.seed)), 1):
data_support, labels_support, \
data_query, labels_query, k_all, _ = [
x.cuda() for x in batch]
test_n_support = opt.test_way * opt.val_shot
test_n_query = opt.test_way * opt.val_query
with torch.no_grad():
emb_support = embedding_net(data_support.reshape([-1] + list(data_support.shape[-3:])))
emb_support = emb_support.reshape(1, test_n_support, -1)
emb_query = embedding_net(data_query.reshape([-1] + list(data_query.shape[-3:])))
emb_query = emb_query.reshape(1, test_n_query, -1)
logit_query = cls_head(k_all, propa_head, emb_query, emb_support, labels_support, opt.test_way, opt.val_shot, is_scale=True)
loss = x_entropy(logit_query.reshape(-1, opt.test_way), labels_query.reshape(-1))
acc = count_accuracy(logit_query.reshape(-1, opt.test_way), labels_query.reshape(-1))
val_accuracies.append(acc.item())
val_losses.append(loss.item())
val_acc_avg = np.mean(np.array(val_accuracies))
val_acc_ci95 = 1.96 * np.std(np.array(val_accuracies)) / np.sqrt(opt.val_episode)
val_loss_avg = np.mean(np.array(val_losses))
if val_acc_avg > max_val_acc:
max_val_acc = val_acc_avg
torch.save({'embedding': embedding_net.state_dict(), 'propa_head': propa_head.state_dict(),
'pre_head': pre_head.state_dict(), 'cls_head': cls_head.state_dict()}, \
os.path.join(opt.save_path, 'best_pretrain_model_meta_infer_val_{}w_{}s_{}.pth'.format(opt.test_way, opt.val_shot, opt.head)))
log(log_file_path, 'Validation Epoch: {}\t\t\tLoss: {:.4f}\tAccuracy: {:.2f} ± {:.2f} % (Best)' \
.format(epoch, val_loss_avg, val_acc_avg, val_acc_ci95))
else:
log(log_file_path, 'Validation Epoch: {}\t\t\tLoss: {:.4f}\tAccuracy: {:.2f} ± {:.2f} %' \
.format(epoch, val_loss_avg, val_acc_avg, val_acc_ci95))
torch.save({'embedding': embedding_net.state_dict(), 'propa_head': propa_head.state_dict(),
'pre_head': pre_head.state_dict(), 'cls_head': cls_head.state_dict()} \
, os.path.join(opt.save_path, 'last_pretrain_epoch_meta_infer.pth'))
if epoch % opt.save_epoch == 0:
torch.save({'embedding': embedding_net.state_dict(), 'propa_head': propa_head.state_dict(),
'pre_head': pre_head.state_dict(), 'cls_head': cls_head.state_dict()} \
, os.path.join(opt.save_path, 'epoch_{}_pretrain_meta_infer.pth'.format(epoch)))
def meta_train(opt, dataset_train, dataset_val, dataset_test, data_loader):
# Dataloader of Gidaris & Komodakis (CVPR 2018)
dloader_train = data_loader(
dataset=dataset_train,
nKnovel=opt.train_way,
nKbase=0,
nExemplars=opt.train_shot, # num training examples per novel category
nTestNovel=opt.train_way * opt.train_query, # num test examples for all the novel categories
nTestBase=0, # num test examples for all the base categories
batch_size=opt.episodes_per_batch,
num_workers=4,
epoch_size=opt.episodes_per_batch * 100, # num of batches per epoch
)
dloader_val = data_loader(
dataset=dataset_val,
nKnovel=opt.test_way,
nKbase=0,
nExemplars=opt.val_shot, # num training examples per novel category
nTestNovel=opt.val_query * opt.test_way, # num test examples for all the novel categories
nTestBase=0, # num test examples for all the base categories
batch_size=1,
num_workers=0,
epoch_size=1 * opt.val_episode, # num of batches per epoch
)
set_gpu(opt.gpu)
check_dir('./experiments/')
check_dir(opt.save_path)
log_file_path = os.path.join(opt.save_path, "train_log.txt")
log(log_file_path, str(vars(opt)))
(embedding_net, propa_head, pre_head, cls_head) = get_model(opt)
# Load saved model checkpoints
saved_models = torch.load(os.path.join(opt.save_path, 'best_pretrain_model_meta_infer_val_{}w_{}s_{}.pth'.format(opt.test_way, opt.val_shot, opt.head)))
embedding_net.load_state_dict(saved_models['embedding'])
embedding_net.eval()
propa_head.load_state_dict(saved_models['propa_head'])
propa_head.eval()
optimizer = torch.optim.SGD([{'params': embedding_net.parameters()},
{'params': propa_head.parameters()},
{'params': cls_head.parameters()}], lr=0.0001, momentum=0.9, \
weight_decay=5e-4, nesterov=True)
lambda_epoch = lambda e: 1.0 if e < 15 else (0.1 if e < 25 else 0.01 if e < 30 else (0.001))
lr_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_epoch, last_epoch=-1)
max_val_acc = 0.0
max_test_acc = 0.0
timer = Timer()
x_entropy = torch.nn.CrossEntropyLoss()
for epoch in range(0, opt.num_epoch + 1):
if epoch != 0:
# Train on the training split
lr_scheduler.step()
# Fetch the current epoch's learning rate
epoch_learning_rate = 0.1
for param_group in optimizer.param_groups:
epoch_learning_rate = param_group['lr']
log(log_file_path, 'Train Epoch: {}\tLearning Rate: {:.4f}'.format(
epoch, epoch_learning_rate))
_, _, _ = [x.train() for x in (embedding_net, propa_head, cls_head)]
train_accuracies = []
train_losses = []
for i, batch in enumerate(tqdm(dloader_train(epoch)), 1):
data_support, labels_support, \
data_query, labels_query, k_all, _ = [
x.cuda() for x in batch]
train_n_support = opt.train_way * opt.train_shot
train_n_query = opt.train_way * opt.train_query
emb_support = embedding_net(data_support.reshape([-1] + list(data_support.shape[-3:])))
emb_support = emb_support.reshape(opt.episodes_per_batch, train_n_support, -1)
emb_query = embedding_net(data_query.reshape([-1] + list(data_query.shape[-3:])))
emb_query = emb_query.reshape(opt.episodes_per_batch, train_n_query, -1)
logit_query = cls_head(k_all, propa_head, emb_query, emb_support, labels_support, opt.train_way, opt.train_shot, is_scale=False)
smoothed_one_hot = one_hot(labels_query.reshape(-1), opt.train_way)
smoothed_one_hot = smoothed_one_hot * (1 - opt.eps) + (1 - smoothed_one_hot) * opt.eps / (opt.train_way - 1)
log_prb = F.log_softmax(logit_query.reshape(-1, opt.train_way), dim=1)
loss = -(smoothed_one_hot * log_prb).sum(dim=1)
loss = loss.mean()
acc = count_accuracy(logit_query.reshape(-1, opt.train_way), labels_query.reshape(-1))
train_accuracies.append(acc.item())
train_losses.append(loss.item())
if (i % 10 == 0):
train_acc_avg = np.mean( | np.array(train_accuracies) | numpy.array |
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import os
from six.moves import urllib
import pandas as pd
HOUSING_PATH = "datasets/housing"
def load_housing_data(housing_path=HOUSING_PATH):
csv_path = os.path.join(housing_path, "housing.csv")
return pd.read_csv(csv_path)
# In[2]:
housing = load_housing_data()
# housing =
housing.head()
# In[3]:
housing.info()
# In[4]:
housing.describe()
# In[5]:
get_ipython().run_line_magic('matplotlib', 'inline')
import matplotlib.pyplot as plt
housing.hist(bins=50, figsize=(10,7))
plt.show()
# In[6]:
import numpy as np
def split_train_set(data, test_ratio):
shuffled_indices = np.random.permutation(len(data))
test_set_size = int(len(data) * test_ratio)
test_indices = shuffled_indices[:test_set_size]
train_indices = shuffled_indices[test_set_size:]
return data.iloc[train_indices], data.iloc[test_indices]
train_set, test_set = split_train_set(housing, 0.2)
print("Train: ", len(train_set), "+ Test: ", len(test_set))
# In[7]:
import hashlib
def test_set_check(identifier, test_ratio, hash):
return hash(np.int64(identifier)).digest()[-1] < 256 * test_ratio
def split_train_test_by_id(data, test_ratio, id_column, hash=hashlib.md5):
ids = data[id_column]
in_test_set = ids.apply(lambda id_: test_set_check(id_, test_ratio, hash))
return data.loc[~in_test_set], data.loc[in_test_set]
housing_with_id = housing.reset_index() # adds an `index` column
train_set, test_set = split_train_test_by_id(housing_with_id, 0.2, "index")
# In[8]:
from sklearn.model_selection import train_test_split
train_set, test_set = train_test_split(housing, test_size=0.2, random_state=42)
# In[9]:
housing.hist(column='median_income', bins=10)
plt.show()
# In[10]:
housing['income_cat'] = np.ceil(housing['median_income']/1.5)
housing.hist('income_cat', bins=10)
plt.show()
housing['income_cat'].where(housing['income_cat'] < 5, 5.0, inplace=True)
housing.hist('income_cat')
plt.show()
# In[11]:
from sklearn.model_selection import StratifiedShuffleSplit
split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
for train_index, test_index in split.split(housing, housing['income_cat']):
strat_train_set = housing.iloc[train_index]
strat_test_set = housing.iloc[test_index]
for set in (strat_train_set, strat_test_set):
set.drop(columns='income_cat', inplace=True)
# In[12]:
housing = strat_train_set.copy()
housing.describe()
# In[13]:
housing.plot(kind="scatter", x="longitude", y="latitude", alpha=0.1)
# In[14]:
housing.plot(kind="scatter", x="longitude", y="latitude", alpha=0.2,
s=housing["population"]/100, label="population",
c="median_house_value", cmap=plt.get_cmap("jet"), colorbar=True)
# In[15]:
corr_matrix = housing.corr()
corr_matrix["median_house_value"].sort_values(ascending=False)
# In[16]:
from pandas.plotting import scatter_matrix
attributes = ["median_house_value", "median_income", "total_rooms", "housing_median_age"]
scatter_matrix(housing[attributes], figsize=(12, 8))
# In[17]:
attributes = ["median_house_value", "households", "total_bedrooms", "population"]
scatter_matrix(housing[attributes], figsize=(12, 8))
# In[18]:
housing.plot(kind="scatter", x="median_income", y="median_house_value", alpha=0.1)
# In[19]:
housing["rooms_per_household"] = housing["total_rooms"] / housing["households"]
housing["bedrooms_per_room"] = housing["total_bedrooms"] / housing["total_rooms"]
housing["population_per_household"] = housing["population"] / housing["households"]
corr_matrix = housing.corr()
corr_matrix["median_house_value"].sort_values(ascending=False)
# In[20]:
housing = strat_train_set.drop(columns="median_house_value")
housing_labels = strat_train_set["median_house_value"].copy()
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy="median")
housing_num = housing.drop(columns="ocean_proximity")
# imputer.fit(housing_num)
# print(imputer.statistics_)
# X = imputer.transform(housing_num)
X = imputer.fit_transform(housing_num)
housing_tr = pd.DataFrame(X, columns=housing_num.columns)
# housing_tr.describe()
# In[21]:
# housing["ocean_proximity"].value_counts()
# from sklearn.preprocessing import LabelEncoder
# encoder = LabelEncoder()
# housing_cat_encoded = encoder.fit_transform(housing["ocean_proximity"])
from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder()
# print(housing["ocean_proximity"].to_numpy().reshape(-1,1).shape)
housing_cat_1hot = encoder.fit_transform(housing["ocean_proximity"].to_numpy().reshape(-1,1))
print(type(housing_cat_1hot))
print(encoder.categories_)
# dfgdh = DataFrameSelector(["ocean_proximity"]).fit_transform(housing)
# print(np.unique(dfgdh))
# from sklearn.preprocessing import LabelBinarizer
# encoder = LabelBinarizer()
# housing_cat_1hot = encoder.fit_transform(housing["ocean_proximity"])
# print(housing_cat_1hot)
# housing_cat_1hot = pd.get_dummies(housing, columns=['ocean_proximity'])
# housing_cat_1hot.head()
# In[22]:
from sklearn.base import BaseEstimator, TransformerMixin
rooms_ix, bedrooms_ix, population_ix, household_ix = 3, 4, 5, 6
class CombinedAttributesAdder(BaseEstimator, TransformerMixin):
def __init__(self, add_bedrooms_per_room = True): # no *args or **kargs
self.add_bedrooms_per_room = add_bedrooms_per_room
def fit(self, X, y=None):
return self # nothing else to do
def transform(self, X, y=None):
rooms_per_household = X[:, rooms_ix] / X[:, household_ix]
population_per_household = X[:, population_ix] / X[:, household_ix]
if self.add_bedrooms_per_room:
bedrooms_per_room = X[:, bedrooms_ix] / X[:, rooms_ix]
return np.c_[X, rooms_per_household, population_per_household,
bedrooms_per_room]
else:
return np.c_[X, rooms_per_household, population_per_household]
attr_adder = CombinedAttributesAdder(add_bedrooms_per_room=False)
housing_extra_attribs = attr_adder.transform(housing.values)
housing_extra_attribs = pd.DataFrame(housing_extra_attribs)
housing_extra_attribs.head()
# print(type(housing.columns))
# In[23]:
from sklearn.base import BaseEstimator, TransformerMixin
class DataFrameSelector(BaseEstimator, TransformerMixin):
def __init__(self, attribute_names):
self.attribute_names = attribute_names
def fit(self, X, y=None):
return self
def transform(self, X):
return X[self.attribute_names].values
# selector = DataFrameSelector(["ocean_proximity"])
# housing_cat_select = selector.fit_transform(housing)
# print(housing_cat_select[:5])
# encoder = LabelBinarizer()
# housing_cat_1hot = encoder.fit_transform(housing_cat_select)
# print(housing_cat_1hot[:5])
# In[24]:
from sklearn.preprocessing import OneHotEncoder
class CatOneHotEncoder (BaseEstimator, TransformerMixin):
# from sklearn.preprocessing import OneHotEncoder
def __init__(self, sparse = False):
self.sparse = sparse
encoder = OneHotEncoder(sparse=self.sparse)
def fit(self, X, y=None):
return self
def transform(self, X):
encoder = OneHotEncoder(sparse=self.sparse)
return encoder.fit_transform(X.reshape(-1,1))
def get_categories(self, X):
return list(np.unique(X))
# def categories_(self, X):
# # encoder = OneHotEncoder(sparse=self.sparse)
# # encoder.fit_transform(X.reshape(-1,1))
# return ["encoder.categories_"]
encoder = CatOneHotEncoder()
encoder.fit(DataFrameSelector(['ocean_proximity']).fit_transform(housing))
# print(encoder.fit_transform(DataFrameSelector(['ocean_proximity']).fit_transform(housing)))
print(encoder.get_categories(housing['ocean_proximity']))
# selector = DataFrameSelector(["ocean_proximity"])
# housing_cat_select = selector.fit_transform(housing)
# print(housing_cat_select[:5])
# encoder = CatEncoder()
# housing_cat_1hot = encoder.fit_transform(housing_cat_select)
# print(type(housing_cat_1hot))
# In[84]:
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import FeatureUnion
num_attribs = list(housing_num)
cat_attribs = ["ocean_proximity"]
num_pipeline = Pipeline([
('selector', DataFrameSelector(list(housing_num))),
('imputer', SimpleImputer(strategy="median")),
('attribs_adder', CombinedAttributesAdder()),
('std_scaler', StandardScaler()),
])
# housing_prepared = num_pipeline.fit_transform(housing)
# print(housing_prepared[:5])
cat_pipeline = Pipeline([
('selector', DataFrameSelector(cat_attribs)),
('1hot_encoder', CatOneHotEncoder())
])
# housing_prepared = cat_pipeline.fit_transform(housing)
# print(housing_prepared[:5])
full_pipeline = FeatureUnion(transformer_list=[
('num_pipeline', num_pipeline),
('cat_pipeline', cat_pipeline)
])
# pipeline = Pipeline([
# ('selector', DataFrameSelector(list(housing_cat_1hot))),
# ('imputer', SimpleImputer(strategy="median")),
# ('attribs_adder', CombinedAttributesAdder()),
# ('std_scaler', StandardScaler()),
# ])
housing_prepared = full_pipeline.fit_transform(housing)
# print(type(housing_prepared))
# print(housing_prepared[:5])
pd.DataFrame(housing_prepared).head()
# In[27]:
from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(housing_prepared, housing_labels)
# some_data = housing.iloc[:10]
# some_labels = housing_labels[:10]
# some_data_prepared = full_pipeline.fit_transform(some_data)
# print(pd.DataFrame(some_data_prepared[:5]))
# print("Predictions:\"", lin_reg.predict(some_data_prepared))
# print(some_data_prepared.shape)
# print(housing_prepared.shape)
from sklearn.metrics import mean_squared_error
housing_predictions = lin_reg.predict(housing_prepared)
lin_mse = mean_squared_error(housing_labels, housing_predictions)
lin_rmse = np.sqrt(lin_mse)
print(lin_rmse)
# In[28]:
from sklearn.tree import DecisionTreeRegressor
tree_reg = DecisionTreeRegressor()
tree_reg.fit(housing_prepared, housing_labels)
housing_predictions = tree_reg.predict(housing_prepared)
tree_rmse = np.sqrt(mean_squared_error(housing_labels, housing_predictions))
print(tree_rmse)
# In[29]:
from sklearn.model_selection import cross_val_score
scores = cross_val_score(tree_reg, housing_prepared, housing_labels,
scoring="neg_mean_squared_error", cv=10)
tree_rmse_scores = np.sqrt(-scores)
# print(rmse_scores)
def display_scores(scores):
print("Scores:", scores)
print("Mean:", scores.mean())
print("Standard deviation:", scores.std())
display_scores(tree_rmse_scores)
# In[30]:
lin_scores = cross_val_score(lin_reg, housing_prepared, housing_labels,
scoring="neg_mean_squared_error", cv=10)
lin_rmse_scores = np.sqrt(-lin_scores)
display_scores(lin_rmse_scores)
# In[31]:
from sklearn.ensemble import RandomForestRegressor
forest_reg = RandomForestRegressor()
forest_reg.fit(housing_prepared, housing_labels)
forest_scores = cross_val_score(forest_reg, housing_prepared, housing_labels,
scoring="neg_mean_squared_error", cv=10)
forest_rmse_scores = np.sqrt(-forest_scores)
display_scores(forest_rmse_scores)
# In[33]:
print(np.sqrt(mean_squared_error(forest_reg.predict(housing_prepared), housing_labels)))
# In[41]:
from sklearn.model_selection import GridSearchCV
# param_grid = [
# {'n_estimators':[3, 10, 30], 'max_features':[2, 4, 6, 8]},
# {'bootstrap':[False], 'n_estimators':[3, 10], 'max_features':[2, 4, 6]}
# ]
param_grid = [
{'n_estimators':[30, 100], 'max_features':[6, 8, 10]}
]
forest_reg = RandomForestRegressor()
grid_search = GridSearchCV(forest_reg, param_grid,
cv=5, scoring='neg_mean_squared_error')
grid_search.fit(housing_prepared, housing_labels)
# In[34]:
# For quick use when restarting the kernel
from sklearn.model_selection import GridSearchCV
# param_grid = [
# {'n_estimators':[3, 10, 30], 'max_features':[2, 4, 6, 8]},
# {'bootstrap':[False], 'n_estimators':[3, 10], 'max_features':[2, 4, 6]}
# ]
param_grid = [
{'n_estimators':[100], 'max_features':[6]}
]
forest_reg = RandomForestRegressor()
grid_search = GridSearchCV(forest_reg, param_grid,
cv=5, scoring='neg_mean_squared_error')
grid_search.fit(housing_prepared, housing_labels)
# In[35]:
print(np.sqrt(-grid_search.best_score_))
print(grid_search.best_params_)
# In[44]:
cvres = grid_search.cv_results_
for mean_score, params in sorted(list(zip(cvres['mean_test_score'], cvres['params'])), reverse=True):
print(np.sqrt(-mean_score), params)
# In[36]:
feature_importances = grid_search.best_estimator_.feature_importances_
# print(feature_importances)
extra_attribs = ["rooms_per_household", "pop_per_household", "bedrooms_per_room"]
cat_one_hot_attribs = encoder.get_categories(housing['ocean_proximity'])
attributes = num_attribs + extra_attribs + cat_one_hot_attribs
attribs_importance_list = sorted(list(zip(feature_importances, attributes)), reverse=True)
for element in attribs_importance_list:
print(element)
_, attribs_importance_order = zip(*attribs_importance_list)
attribs_importance_order = list(attribs_importance_order)
print(attribs_importance_order)
# In[37]:
final_model = grid_search.best_estimator_
X_test = strat_test_set.drop(columns="median_house_value")
y_test = strat_test_set["median_house_value"].copy()
X_test_prepared = full_pipeline.transform(X_test)
final_predictions = final_model.predict(X_test_prepared)
final_rmse = np.sqrt(mean_squared_error(y_test, final_predictions))
print(final_rmse)
# In[73]:
from sklearn.svm import SVR
SupportVectorMachine = SVR()
svr_param_grid = [
{'kernel':["linear"], 'C':[0.3, 1, 3]},
{'kernel':["rbf"], 'C':[1, 3], 'gamma':[0.03, 0.1]}
]
svr_grid_search = GridSearchCV(SupportVectorMachine, svr_param_grid,
cv=5, scoring="neg_mean_squared_error")
svr_grid_search.fit(housing_prepared, housing_labels)
# In[84]:
svr_cv_results = svr_grid_search.cv_results_
# for sorted(score, param in svr_cv_results['mean_test_score'], svr_cv_results['params'], reverse=True):
# print(score, param)
for element in sorted(list(zip(np.sqrt(-svr_cv_results['mean_test_score']), svr_cv_results['params']))):
print(element)
# print(svr_cv_results['params'])
# In[85]:
svr_param_grid = [
{'kernel':["linear"], 'C':[3, 10, 30, 100]},
{'kernel':["rbf"], 'C':[10, 3], 'gamma':[3, 1]}
]
svr_grid_search = GridSearchCV(SupportVectorMachine, svr_param_grid,
cv=5, scoring="neg_mean_squared_error")
svr_grid_search.fit(housing_prepared, housing_labels)
# In[87]:
svr_cv_results = svr_grid_search.cv_results_
# for sorted(score, param in svr_cv_results['mean_test_score'], svr_cv_results['params'], reverse=True):
# print(score, param)
for element in sorted(list(zip(np.sqrt(-svr_cv_results['mean_test_score']), svr_cv_results['params']))):
print(element)
# print(svr_cv_results['params'])
# In[38]:
housing_reduced = pd.DataFrame(housing_prepared)
housing_reduced.columns = attributes
housing_reduced = housing_reduced[attribs_importance_order[:8]]
housing_reduced.head()
# housing_prepared_small = housing_prepared[attribs_importance_order[:8]]
# attribs_importance_order[:8]
# pd.DataFrame(housing_prepared).head()
# print(type(housing_prepared))
# In[39]:
class ReduceFeatures(BaseEstimator, TransformerMixin):
def __init__(self, attribs, attribs_order, num=8):
self.attribs = attribs
self.attribs_order = attribs_order
self.num = num
def fit(self, X, y=None):
return self
def transform(self, X, y=None) :
X_dataframe = pd.DataFrame(X)
X_dataframe.columns = self.attribs
X_reduced = X_dataframe[self.attribs_order[:(self.num)]]
return X_reduced.values
reducer = ReduceFeatures(attributes, attribs_importance_order)
housing_reduced = reducer.fit_transform(housing_prepared)
print(housing_reduced[:5])
# print(housing_reduced.head())
# housing_reduced = housing_reduced[attribs_importance_order[:8]]
# print(housing_reduced[:5])
# In[40]:
reducer_pipeline = Pipeline([
('full_pipeline', full_pipeline),
('reducer', ReduceFeatures(attributes, attribs_importance_order))
])
housing_reduced = reducer_pipeline.fit_transform(housing)
print(housing_reduced[:5])
# In[70]:
# param_grid = [
# {'n_estimators':[30, 100]}
# ]
param_grid = [
{'n_estimators':[30, 100]}
]
grid_search_red = GridSearchCV(forest_reg, param_grid,
cv=5, scoring='neg_mean_squared_error')
grid_search_red.fit(housing_reduced, housing_labels)
cvres_red = grid_search_red.cv_results_
for mean_score, params in sorted(list(zip(cvres_red['mean_test_score'], cvres_red['params'])), reverse=True):
print(np.sqrt(-mean_score), params)
# In[87]:
final_model_red = grid_search_red.best_estimator_
X_test = strat_test_set.drop(columns="median_house_value")
y_test = strat_test_set["median_house_value"].copy()
X_test_prepared = reducer_pipeline.transform(X_test)
final_predictions = final_model_red.predict(X_test_prepared)
final_rmse = np.sqrt(mean_squared_error(y_test, final_predictions))
print(final_rmse)
# In[88]:
final_model_red = RandomForestRegressor(n_estimators=100)
final_model_red.fit(reducer_pipeline.fit_transform(housing), housing_labels)
X_test = strat_test_set.drop(columns="median_house_value")
y_test = strat_test_set["median_house_value"].copy()
X_test_prepared = reducer_pipeline.transform(X_test)
final_predictions = final_model_red.predict(X_test_prepared)
final_rmse = np.sqrt(mean_squared_error(y_test, final_predictions))
print(final_rmse)
# In[ ]:
# In[41]:
list(attributes)
# In[95]:
class HouseValueQuirksElimination(BaseEstimator, TransformerMixin):
def __init__(self, prices):
self.prices = prices.to_numpy()
def fit(self, X, y=None):
return self
def transform(self, X, y=None):
for i in [500000, 450000, 350000]:
if i == 500000:
ix, = np.where(self.prices==i)
print(len(ix))
else:
ix_i, = np.where(self.prices==i)
print(len(ix_i))
ix = np.append(ix, ix_i)
return np.delete(X, ix, 0)
quirks_remover = HouseValueQuirksElimination(housing_labels)
# housing_quirks = quirks_remover.fit_transform(housing)
# In[117]:
some_data = DataFrameSelector(list(housing)).fit_transform(housing)
selector = housing_labels.to_numpy()
# print(type(selector))
# print(some_data[:5])
# i, = np.where(selector==500000)
# print(len(i))
# print(type(i))
# print(i.shape)
# ix = np.empty(1)
# print(type(ix))
# print(ix.shape)
# print(ix)
# del ix
for i in [500001, 500000, 450000, 350000]:
if i == 500000:
ix, = np.where(selector==i)
print(len(ix))
else:
ix_i, = np.where(selector==i)
print(len(ix_i))
ix = np.append(ix, ix_i)
print(len(ix))
# if ix exist:
# print("Is")
# else:
# print("Not")
some_data_prepared = np.delete(some_data, ix, 0)
print(some_data.shape)
print(some_data_prepared.shape)
# plot()
# In[131]:
print(strat_train_set['median_house_value'].value_counts().head(10))
quirks = [500001, 450000, 350000]
strat_train_set_quirks = strat_train_set[~strat_train_set['median_house_value'].isin(quirks)]
strat_test_set_quirks = strat_test_set[~strat_test_set['median_house_value'].isin(quirks)]
# strat_train_set_quirks.describe()
# strat_test_set_quirks.describe()
# print(~strat_train_set['median_house_value'].isin([500000, 450000, 350000]))
# print(type(strat_train_set.index[strat_train_set['median_house_value'==500000]]))
# df.index[df['BoolCol'] == True].tolist()
# idx = strat_train_set[1].index
# print(idx)
# print(strat_test_set[strat_test_set['median_house_value'].isin([500000])])
# strat_train_set.head()
# In[136]:
housing_quirks = strat_train_set_quirks.drop(columns='median_house_value')
housing_labels_quirks = strat_train_set_quirks['median_house_value'].copy()
housing_quirks_prepared = full_pipeline.fit_transform(housing_quirks)
forest_reg_quirks = RandomForestRegressor()
param_grid = [
{'n_estimators':[100], 'max_features':[6, 8, 10]}
]
grid_search_quirks = GridSearchCV(forest_reg_quirks, param_grid,
cv=5, scoring='neg_mean_squared_error')
grid_search_quirks.fit(housing_quirks_prepared, housing_labels_quirks)
cvres_quirks = grid_search_quirks.cv_results_
for mean_score, params in sorted(list(zip(cvres_quirks['mean_test_score'], cvres_quirks['params'])), reverse=True):
print( | np.sqrt(-mean_score) | numpy.sqrt |
#!/usr/bin/python
import scipy
import scipy.signal
import numpy
"""
Control theory helper functions library.
Wraps scipy routines to provide control functions including:
- Pole placement
- Steady-state LQR gain
- Steady-state Kalman gain
- Controllability and observability matrices
- Continuous to discrete transformations for the system and noise matrices
Inspired by 971's control helpers library
"""
__author__ = '<NAME> (<EMAIL>)'
def _validate_system(A, B, C, D):
if A is not None:
A = numpy.asmatrix(A)
if B is not None:
B = numpy.asmatrix(B)
if C is not None:
C = numpy.asmatrix(C)
if D is not None:
D = numpy.asmatrix(D)
assert A is not None and A.shape[0] == A.shape[1], "A must be square"
if B is not None:
assert B.shape[0] == A.shape[0], "A.shape %s and B.shape %s must be compatible" % (A.shape, B.shape)
if C is not None:
assert C.shape[1] == A.shape[0], "A.shape %s and C.shape %s must be compatible" % (A.shape, C.shape)
if B is not None and C is not None and D is not None:
assert D.shape[0] == C.shape[0], "C.shape %s and D.shape %s must be compatible" % (C.shape, D.shape)
assert D.shape[1] == B.shape[1], "B.shape %s and D.shape %s must be compatible" % (B.shape, D.shape)
def place(A, B, poles):
"""
Find the m*n matrix K such that the poles (eigenvalues) of A-BK are at the
desired locations. Works on both discrete-time and continuous-time systems.
Note: If you are using continuous-time matrices, poles should be negative
to acheive stability while with discrete-time matrices they should just be
less than 1
Args:
A: n*n system dynamics matrix
B: n*m control signal matrix
poles: complex array of desired pole locations
For every complex pole a+bi, its conjugate a-bi must also be a pole
Returns:
K: m*n gains matrix such that u = -Kx
"""
A = numpy.asmatrix(A)
B = numpy.asmatrix(B)
_validate_system(A, B, None, None)
assert len(poles) == A.shape[0], "The number of poles (%i) must be equal to the rank of the system (%i)." % (len(poles), A.shape[0])
assert numpy.linalg.matrix_rank(controllability(A, B)) == A.shape[0], "System must be completely controllable to do pole placement."
result = scipy.signal.place_poles(A, B, poles)
for req, res in zip(result.requested_poles, result.computed_poles):
if abs(req - res) > 1e-3:
print("Warning: Pole %s could not be assigned as given and was instead assigned as %s" % (req, res))
return result.gain_matrix
def controllability(A, B):
"""
Calculate the controllability matrix of the system defined by A and B.
Works on both discrete-time and continuous-time systems.
In a fully controllable system, rank(controllability(A, B)) == n
Args:
A: n*n system dynamics matrix
B: n*m control signal matrix
Returns:
E: n*nm controllability matrix
"""
A = numpy.asmatrix(A)
B = numpy.asmatrix(B)
_validate_system(A, B, None, None)
n = A.shape[0]
m = B.shape[1]
E = numpy.asmatrix(numpy.zeros((n, n*m)))
x = B
for i in range(0, n):
j = i * m
E[:n, j:j+m] = x
x = A * x
return E
def observability(A, C):
"""
Calculate the observability matrix of the system defined by A and C.
Works on both discrete-time and continuous-time systems.
In a fully observable system, rank(controllability(A, C)) == n
Observability is the dual of controllability, meaning that
observability(A, C) = controllability(A.T, C.T).T
Args:
A: n*n system dynamics matrix
C: n*q measurement signal matrix
Returns:
O: nq*n observability matrix
"""
A = numpy.asmatrix(A)
C = numpy.asmatrix(C)
_validate_system(A, None, C, None)
n = A.shape[0]
q = C.shape[0]
O = numpy.asmatrix(numpy.zeros((n*q, n)))
y = C
for i in range(0, n):
j = i * q
O[j:j+q, :n] = y
y = y * A
return O
def c2d(A, B, dt, Q = None, R = None):
"""
Transform the continuous-time system dx/dt = Ax + Bu into the discrete-time
formulation x(n+1) = Ax(n) + Bu(n).
Args:
A: n*n continuous-time system dynamics matrix
B: n*m continuous-time control signal matrix
dt: time step of the discretized process
Q (optional): n*n continuous-time process noise covariance matrix
R (optional): q*q continuous-time measurement noise covariance matrix
Returns
Tuple (A_d, B_d, Q_d, R_d)
A_d: n*n discrete-time system dynamics matrix
B_d: n*m discrete-time control signal matrix
Q_d: n*n discrete-time process noise covariance matrix (None if no Q given)
R_d: q*q discrete-time measurement noise covariance matrix (None if no R given)
"""
_validate_system(A, B, None, None)
A = numpy.asmatrix(A)
B = numpy.asmatrix(B)
n = A.shape[0]
m = B.shape[1]
F = numpy.asmatrix(numpy.zeros((n + m, n + m)))
F[:n, :n] = A
F[:n, n:n+m] = B
G = scipy.linalg.expm(F * dt)
A_d = G[:n, :n]
B_d = G[:n, n:n+m]
Q_d = R_d = None
if Q is not None and R is not None:
Q = numpy.asmatrix(Q)
R = numpy.asmatrix(R)
assert Q.shape == A.shape, "The dimensions of Q %s must match those of A %s" % (Q.shape, A.shape)
assert R.shape[0] == R.shape[1], "R must be square but is instead %ix%i" % (R.shape[0], R.shape[1])
H = numpy.asmatrix(numpy.zeros((n+n, n+n)))
H[:n, :n] = -A
H[n:n+n, n:n+n] = A
H[:n, n:n+n] = Q
I = numpy.asmatrix(scipy.linalg.expm(H * dt))
Q_d = numpy.asmatrix(I[n:n+n, n:n+n].T * I[:n, n:n+n])
R_d = | numpy.asmatrix(R / dt) | numpy.asmatrix |
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import animation
l = 0.1
n = 10
T0 = 0
T1s = 40
T2s = 40
dx = l/10
alpha = 0.0001
t_final = 60
dt = 0.1
x = np.linspace(dx/2, l-dx/2, n)
T = np.ones(n)*T0
dTdt = | np.empty(n) | numpy.empty |
from collections import OrderedDict
from scipy.spatial.transform import Rotation as R
from scipy.spatial.transform import Slerp
import numpy as np
import json
import multiprocessing as mp
from tqdm import tqdm
def pretty_print(ob):
print(json.dumps(ob, indent=4))
def euler_to_rot(angles):
# Euler ZYX to Rot
# Note that towr has (x, y, z) order
x = angles[0]
y = angles[1]
z = angles[2]
ret = np.array([
np.cos(y) * np.cos(z),
np.cos(z) * np.sin(x) * np.sin(y) - np.cos(x) * np.sin(z),
np.sin(x) * np.sin(z) + np.cos(x) * np.cos(z) * np.sin(y),
np.cos(y) * np.sin(z),
np.cos(x) * np.cos(z) + | np.sin(x) | numpy.sin |
import unittest
import numpy as np
from pyml.linear_model.classification import sigmoid
from pyml.linear_model.classification import LogisticClassifier
class test_classification(unittest.TestCase):
def test_sigmoid(self):
result = sigmoid(np.array([0,2]))
true_result = np.array([0.5, 0.88079708])
np.testing.assert_almost_equal(result, true_result)
def test_propagate(self):
w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])
test_dw = np.array([[0.99993216],[1.99980262]])
test_db = 0.49993523062470574
test_cost = 6.000064773192205
lc = LogisticClassifier()
grads, cost = lc.propagate(w, b, X, Y)
np.testing.assert_array_almost_equal(grads['dw'], test_dw)
np.testing.assert_array_almost_equal(grads['db'], test_db)
np.testing.assert_array_almost_equal(cost, test_cost)
def test_optimier(self):
w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])
std_w = np.array([[0.1124579 ],[0.23106775]])
std_b = np.array(1.5593049248448891)
std_dw = np.array([[0.90158428],[1.76250842]])
std_db = np.array(0.4304620716786828)
std_cost = [6.000064773192205]
lc = LogisticClassifier(learning_rate = 0.009)
params, grads, costs = lc.optimize(w, b, X, Y, num_iterations= 100)
np.testing.assert_array_almost_equal(params['w'], std_w)
np.testing.assert_array_almost_equal(params['b'], std_b)
np.testing.assert_array_almost_equal(grads['dw'], std_dw)
np.testing.assert_array_almost_equal(grads['db'], std_db)
np.testing.assert_array_almost_equal(costs, std_cost)
def test_pred(self):
w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])
lc = LogisticClassifier()
lc.parameters['w'] = w
lc.parameters['b'] = b
y_pred = lc.predict(X.T)
std_y_pred = | np.array([1,1]) | numpy.array |
import numpy as np
from scipy.interpolate import LinearNDInterpolator, interp1d
from astropy import table
from astropy.table import Table, Column
import warnings
def get_track_meta(track, key="FeH"):
""" get meta info from a track """
assert key in track.meta.keys()
return track.meta[key]
def find_rank_1d(arr, val, sort=False):
""" return ind of the two elements in *arr* that bracket *val* """
if sort:
arr = np.sort(arr)
sub = np.where((arr[:-1] < val) & (arr[1:] >= val))[0]
assert len(sub) > 0
return np.hstack((sub, sub + 1))
def get_track_item_given_eeps(track, eeps):
""" return track items given a set of eeps """
ind = np.zeros((len(track, )), dtype=bool)
for eep in eeps:
ind |= track["_eep"] == eep
return track[ind]
def calc_weight(arr, val, norm=1.):
""" calculate normalized weight """
weight = np.abs(arr - val)
weight *= norm / np.sum(weight)
return np.array(weight)
def table_linear_combination(t, weight):
""" given weight, return the linear combination of each row for each column
"""
assert len(t) == len(weight)
new_cols = []
colnames = t.colnames
ncols = len(colnames)
for i in range(ncols):
if t.dtype[i] in (np.int, np.float):
colname = colnames[i]
new_cols.append(
Column(np.array([np.sum(t[colname].data * weight)]), colname))
return Table(new_cols)
class StarObject():
def __init__(self, t):
assert len(t) == 1
colnames = t.colnames
ncols = len(colnames)
for i in range(ncols):
self.__setattr__(colnames[i], t[colnames[i]].data[0])
class TrackSet:
""" a set of tracks """
data = []
eep_bounds = (1, 808)
default_coord = ["_lgmass", "_feh", "_lgage", "_eep"]
bci = None
def __init__(self, tracks,
metadict=dict(minit="initial_mass",
feh="FEH",
eep="EEPS",
mbol="Mbol")):
""" initialization of track set object """
self.metadict = metadict
self.data = np.array(tracks)
self.grid_minit = np.array(
[get_track_meta(track, metadict["minit"]) for track in tracks])
self.grid_feh = np.array(
[get_track_meta(track, metadict["feh"]) for track in tracks])
#self.grid_EEP = [get_track_meta(track, metadict["eep"]) for track in tracks]
# every track starts from EEP=1
self.grid_EEP0 = np.array([np.min(_["_eep"]) for _ in self.data])
self.grid_EEP1 = np.array([np.max(_["_eep"]) for _ in self.data])
self.u_minit = np.unique(self.grid_minit)
self.u_feh = np.unique(self.grid_feh)
self.min_minit = np.min(self.u_minit)
self.max_minit = np.max(self.u_minit)
self.min_feh = np.min(self.u_feh)
self.max_feh = np.max(self.u_feh)
self.min_eep = np.min(self.grid_EEP0)
self.max_eep = np.max(self.grid_EEP1)
def get_track4(self, mass_feh=(1.01, 0.01)):
""" return the 4 neighboring stellar tracks """
test_minit, test_feh = np.array(mass_feh, dtype=np.float)
# assert Minit [Fe/H] in range
try:
assert self.min_minit < test_minit <= self.max_minit
assert self.min_feh < test_feh <= self.max_feh
except AssertionError as ae:
return None
# 1. locate 4 tracks
ind_minit = find_rank_1d(self.u_minit, test_minit)
ind_feh = find_rank_1d(self.u_feh, test_feh)
val_minit = self.u_minit[ind_minit]
val_feh = self.u_feh[ind_feh]
ind_track = np.where(np.logical_and(
(self.grid_minit == val_minit[0]) | (
self.grid_minit == val_minit[1]),
(self.grid_feh == val_feh[0]) | (self.grid_feh == val_feh[1])))[0]
track4 = self.data[ind_track]
return track4
def get_track4_unstructured(self, mass_feh=(1.01, 0.01)):
""" return the 4 neighboring stellar tracks given unstructured grid """
test_minit, test_feh = | np.array(mass_feh, dtype=np.float) | numpy.array |
# A weighted Energy Distance approach
from scipy.spatial import distance
import numpy as np
def WED(X, Y):
"""
Calculates the weighted Energy Distance between two sets of planetary systems (or any other user defined set).
Parameters
----------
X : list of 'n' planets (in d-dimensional phase space) in following format:
[(x_1,x_2,....,x_n, w_x)_1, (x_1,x_2,....,x_d, w_x)_2,....,(x_1,x_2,....,x_d, w_x)_n]
Y : list of 'm' planets (in d-dimensional phase space) in following format:
[(y_1,y_2,....,y_n, w_y)_1, (y_1,y_2,....,y_d, w_y)_2,....,(y_1,y_2,....,y_d, w_y)_n]
Returns
-------
Weighted Energy Distance
Examples
--------
from PASSta import WED
WED([(1,2,3),(1.1,2.1,3.1)], [(1,2,3),(1.2,2.2,3.2)]) #---> 0.274
WED([(1,2,3)], [(1,2,3),(1.2,2.2,3.2)]) #---> 0.388
"""
n, m = len(X), len(Y)
# Check if X or Y are empty
if n == 0 or m == 0:
raise ValueError("WED assumes both X and Y are not empty")
# Get phase space dimensional and check that all dimensions of X_i and Y_j are the same
xdim = len(X[0])
ydim = len(Y[0])
if xdim != ydim:
raise ValueError("Inconsistent planet phase space dimensions")
for x in X:
if xdim != len(x):
raise ValueError("All X elements must be of same size")
for y in Y:
if ydim != len(y):
raise ValueError("All Y elements must be of same size")
# Get X,Y weight vectors and their sums
W_x = np.array([xi[xdim-1] for xi in X])
W_y = np.array([yi[ydim-1] for yi in Y])
W_X, W_Y = sum(W_x), sum(W_y)
Xd = [x[:xdim-1] for x in X]
Yd = [y[:ydim-1] for y in Y]
A_DistMat = distance.cdist(Xd, Yd, 'euclidean')
A = sum(sum((np.outer(W_x, W_y) * A_DistMat))) / (W_X * W_Y)
B_DistMat = distance.cdist(Xd, Xd, 'euclidean')
B = sum(sum(( | np.outer(W_x, W_x) | numpy.outer |
import logging
import os
import time
from typing import List, Tuple
import numpy as np
import torch
from torch import Tensor
from ujson import load as load_json
from ..base import DataLoader, LocalDataset
class MNISTDataLoader(DataLoader):
def __init__(self, data_dir='./../../../data/MNIST', batch_size=10):
super().__init__(data_dir, batch_size, batch_size)
@staticmethod
def read_data(train_data_dir, test_data_dir):
"""
Parses data in given train and test data directories
assumes:
- the data in the input directories are .json files with
keys 'users' and 'user_data'
- the set of train set users is the same as the set of test set users
Return:
clients: list of non-unique client ids
groups: list of group ids; empty list if none found
train_data: dictionary of train data
test_data: dictionary of test data
"""
start_time = time.perf_counter()
groups = list()
train_data = dict()
test_data = dict()
for f in (file for file in os.listdir(train_data_dir) if file.endswith('.json')):
file_path = os.path.join(train_data_dir, f)
with open(file_path, 'r') as fd:
cdata = load_json(fd)
if 'hierarchies' in cdata:
groups.extend(cdata['hierarchies'])
train_data.update(cdata['user_data'])
for f in (file for file in os.listdir(test_data_dir) if file.endswith('.json')):
file_path = os.path.join(test_data_dir, f)
with open(file_path, 'r') as fd:
cdata = load_json(fd)
test_data.update(cdata['user_data'])
clients = sorted(cdata['users'])
logging.info(f'Time spent reading MNIST JSONs: {time.perf_counter() - start_time}')
return clients, groups, train_data, test_data
def batch_data(self, data, batch_size) -> List[Tuple[Tensor, Tensor]]:
"""
data is a dict := {'x': [numpy array], 'y': [numpy array]} (on one client)
returns x, y, which are both numpy array of length: batch_size
"""
data_x = data['x']
data_y = data['y']
# randomly shuffle data
np.random.seed(100)
rng_state = np.random.get_state()
np.random.shuffle(data_x)
np.random.set_state(rng_state)
np.random.shuffle(data_y)
# loop through mini-batches
batch_data = list()
for i in range(0, len(data_x), batch_size):
batched_x = data_x[i:i + batch_size]
batched_y = data_y[i:i + batch_size]
batched_x = torch.from_numpy( | np.asarray(batched_x) | numpy.asarray |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Oct 30 13:12:06 2020
@author: peter
"""
import numpy as np
from pathlib import Path
import shutil
import json
import tifffile
import quantities as pq
import scipy.interpolate as interp
import scipy.ndimage as ndimage
import scipy.signal as signal
import pandas as pd
import datetime
import pdb
import re
import f.general_functions as gf
import f.ephys_functions as ef
def get_events_exclude_surround_events(
tc,
std,
surround_tc,
surround_std,
z_score=3,
surround_z=7,
exclude_first=0,
max_overlap=0.75,
excluded_circle=None,
excluded_dead=None,
):
ev = detect_events(tc, std, z_score=z_score, exclude_first=exclude_first)
surrounds_ev = detect_events(
tc, std, z_score=surround_z, exclude_first=exclude_first
)
excluded_dict = {}
dict_drop = []
for key in ev.keys():
if type(key) == str:
continue
if key not in surrounds_ev.keys():
continue
sur_e = surrounds_ev[key].T
e = ev[key].T
# if a detected surround event overlaps for more than max_overlap, then remove
# detects any overlaps
overlapping = np.logical_and(
e[:, 0, None] < sur_e[None, :, 1], e[:, 1, None] >= sur_e[None, :, 0]
)
if not np.any(overlapping):
continue
drop = []
wh = np.where(overlapping)
# now detect size of overlap and delete if proportionally greater than max overlap
for idx in range(len(wh[0])):
overlap = min(e[wh[0][idx], 1], sur_e[wh[1][idx], 1]) - max(
e[wh[0][idx], 0], sur_e[wh[1][idx], 0]
)
if overlap > max_overlap * (e[wh[0][idx], 1] - e[wh[0][idx], 0]):
drop.append(wh[0][idx])
# pdb.set_trace()
exc_e = np.array([x for ii, x in enumerate(e) if ii in drop])
keep_e = np.array([x for ii, x in enumerate(e) if ii not in drop])
excluded_dict[key] = exc_e.T
if len(keep_e) > 0:
ev[key] = keep_e.T
else:
dict_drop.append(key)
# delete empty fields
for key in dict_drop:
del ev[key]
# exclude ROIs on edge of illumination
if excluded_circle is not None:
circle_dict = {}
for idx in excluded_circle:
if idx in ev.keys():
circle_dict[idx] = ev[idx]
del ev[idx]
ev["excluded_circle_events"] = circle_dict
# exclude ROIs on edge of illumination
if excluded_dead is not None:
dead_dict = {}
if len(excluded_dead) > 0:
for idx in excluded_dead:
if idx in ev.keys():
dead_dict[idx] = ev[idx]
del ev[idx]
else:
pass
ev["excluded_dead_events"] = dead_dict
# include the surround data
ev["surround_events"] = surrounds_ev
ev["excluded_events"] = excluded_dict
return ev
def get_events_exclude_simultaneous_events(
tc,
std,
z_score=3,
exclude_first=0,
max_events=5,
overlap=0.75,
excluded_circle=None,
excluded_dead=None,
):
ev, excluded_dict = detect_events_remove_simultaneous(
tc,
std,
z_score=z_score,
exclude_first=exclude_first,
max_overlap=overlap,
max_events=max_events,
)
# exclude ROIs on edge of illumination
if excluded_circle is not None:
circle_dict = {}
for idx in excluded_circle:
if idx in ev.keys():
circle_dict[idx] = ev[idx]
del ev[idx]
ev["excluded_circle_events"] = circle_dict
# exclude ROIs on edge of illumination
if excluded_dead is not None:
dead_dict = {}
if len(excluded_dead) > 0:
for idx in excluded_dead:
if idx in ev.keys():
dead_dict[idx] = ev[idx]
del ev[idx]
else:
pass
ev["excluded_dead_events"] = dead_dict
ev["excluded_events"] = excluded_dict
ev["surround_events"] = excluded_dict
print("Check this - surrounds and exclude the same")
return ev
def detect_events_remove_simultaneous(
tc, std, z_score=3, exclude_first=0, max_events=5, max_overlap=0.5
):
tc_filt = ndimage.gaussian_filter(tc, (0, 3))
std_filt = ndimage.gaussian_filter(std, (0, 3))
tc_filt[:, :exclude_first] = 1
events = np.abs(tc_filt - 1) > z_score * std_filt
# Use closing to join split events and remove small events
struc = np.zeros((3, 5))
struc[1, :] = 1
events = ndimage.binary_opening(events, structure=struc, iterations=2)
events = ndimage.binary_closing(events, structure=struc, iterations=2)
# now count simultaneous events and remove those where they are
num_events = np.sum(events, 0)
excluded_events = num_events > max_events
excluded_time = np.where(excluded_events)[0]
wh = np.where(events)
idxs, locs = np.unique(wh[0], return_index=True)
locs = np.append(locs, len(wh[0]))
excluded_result = {}
result = {}
for i, idx in enumerate(idxs):
llocs = wh[1][locs[i] : locs[i + 1]]
split_locs = np.array(recursive_split_locs(llocs))
# check if they have both positive and negative going - messes with integration later
t = tc_filt[idx, :]
corr_locs = correct_event_signs(t, split_locs)
overlap = np.sum(np.isin(llocs, excluded_time).astype(int)) / len(llocs)
if overlap > max_overlap:
excluded_result[idx] = corr_locs.T
else:
result[idx] = corr_locs.T
result["tc_filt"] = tc_filt
result["tc"] = tc
return result, excluded_result
def get_surround_masks(masks, surround_rad=20, dilate=True):
def get_bounding_circle_radius(masks):
rows, cols = np.any(masks, axis=-1), np.any(masks, axis=-2)
rs = np.apply_along_axis(first_last, -1, rows)
cs = np.apply_along_axis(first_last, -1, cols)
centers = np.array(
[rs[:, 0] + (rs[:, 1] - rs[:, 0]) / 2, cs[:, 0] + (cs[:, 1] - cs[:, 0]) / 2]
).T
# bounding radius is the hypotenuse /2
radii = np.sqrt((cs[:, 0] - cs[:, 0]) ** 2 + (rs[:, 1] - rs[:, 0]) ** 2) / 2
return radii, centers
def first_last(arr_1d):
return np.where(arr_1d)[0][[0, -1]]
# avoid border effects/bleedthrough by dilating existing rois
structure = np.ones((3, 3, 3))
structure[0::2, ...] = 0
dilated_masks = ndimage.binary_dilation(masks, structure=structure, iterations=4)
roi_rads, centers = get_bounding_circle_radius(dilated_masks)
x, y = np.indices(masks.shape[-2:])
rs = np.sqrt(
(x[None, ...] - centers[:, 0, None, None]) ** 2
+ (y[None, ...] - centers[:, 1, None, None]) ** 2
)
surround_roi = np.logical_xor(
dilated_masks, rs < roi_rads[:, None, None] + surround_rad
)
return surround_roi
def get_surround_masks_cellfree(masks, surround_rad=50, dilate=True):
all_masks = np.any(masks, axis=0)
# avoid border effects/bleedthrough by dilating existing rois
structure = np.ones((3, 3, 3))
structure[0::2, ...] = 0
dilated_masks = ndimage.binary_dilation(masks, structure=structure, iterations=4)
centers = np.array([ndimage.center_of_mass(m) for m in dilated_masks])
x, y = np.indices(masks.shape[-2:])
rs = np.sqrt(
(x[None, ...] - centers[:, 0, None, None]) ** 2
+ (y[None, ...] - centers[:, 1, None, None]) ** 2
)
surround_roi = np.logical_and(~all_masks, rs < surround_rad)
# see if the area is too small
areas = np.sum(surround_roi, axis=(-2, -1))
# check nowhere too small
small = areas < 2000
if np.any(small):
for new_rs in range(surround_rad, 2 * surround_rad, 10):
small = areas < 2000
surround_roi[small] = np.logical_and(~all_masks, rs[small, ...] < new_rs)
if not np.any(small):
break
small = areas < 2000
# revert back to normal behaviour - just take an area around and dont care about cells
if np.any(small):
surround_roi[small] = np.logical_and(masks[small], rs[small, ...] < new_rs)
return surround_roi
def get_observation_length(event_dict):
tc = event_dict["tc_filt"]
exclude_dict = event_dict["surround_events"]
length = tc.shape[1]
lengths = []
# count as non-observed any time during a surround event
for i in range(tc.shape[0]):
if i in exclude_dict.keys():
lengths.append(
length - np.sum(exclude_dict[i].T[:, 1] - exclude_dict[i].T[:, 0])
)
else:
lengths.append(length)
return np.array(lengths)
def apply_exclusion(exclude_dict, tc):
excluded_tc = np.copy(tc)
for roi in exclude_dict.keys():
for i in range(exclude_dict[roi].shape[-1]):
ids = exclude_dict[roi][:, i]
excluded_tc[roi, ids[0] : ids[1]] = 1
return excluded_tc
def soft_threshold(arr, thresh, to=1):
# Thresholds towards to value
res = np.copy(arr)
wh = np.where(np.abs(arr - to) < thresh)
n_wh = np.where(np.abs(arr - to) >= thresh)
sgn = np.sign(arr - to)
res[wh] = to
res[n_wh] -= sgn[n_wh] * thresh
return res
def split_event(t, ids):
# splits a zero-(actually 1) crossing event into multiple non-zero crossing events recursively
# removes one point
if not np.logical_and(
np.any(t[ids[0] : ids[1]] - 1 > 0), np.any(t[ids[0] : ids[1]] - 1 < 0)
):
return [tuple(ids)]
else:
zer_loc = np.argmin(np.abs(t[ids[0] : ids[1]] - 1)) + ids[0]
return split_event(t, (ids[0], zer_loc)) + split_event(t, (zer_loc + 1, ids[1]))
def correct_event_signs(t, llocs):
corr_locs = []
for id_idx, ids in enumerate(llocs):
if np.logical_and(
np.any(t[ids[0] : ids[1]] - 1 > 0), np.any(t[ids[0] : ids[1]] - 1 < 0)
):
split_ids = split_event(t, ids)
corr_locs.extend(split_ids)
else:
corr_locs.append(ids)
corr_locs = np.array(corr_locs)
# if we have split into a zero size (due to boundary issue in split events), remove
if np.any((corr_locs[:, 1] - corr_locs[:, 0]) < 1):
corr_locs = corr_locs[(corr_locs[:, 1] - corr_locs[:, 0]) > 0]
return corr_locs
def recursive_split_locs(seq):
# splits a sequence into n adjacent sequences
diff = np.diff(seq)
if not np.any(diff != 1):
return [(seq[0], seq[-1])]
else:
wh = np.where(diff != 1)[0][0] + 1
return recursive_split_locs(seq[:wh]) + recursive_split_locs(seq[wh:])
def detect_events(tc, std, z_score=3, exclude_first=0):
tc_filt = ndimage.gaussian_filter(tc, (0, 3))
std_filt = ndimage.gaussian_filter(std, (0, 3))
tc_filt[:, :exclude_first] = 1
events = np.abs(tc_filt - 1) > z_score * std_filt
# Use closing to join split events and remove small events
struc = np.zeros((3, 5))
struc[1, :] = 1
events = ndimage.binary_opening(events, structure=struc, iterations=2)
events = ndimage.binary_closing(events, structure=struc, iterations=2)
wh = np.where(events)
idxs, locs = np.unique(wh[0], return_index=True)
locs = np.append(locs, len(wh[0]))
result = {}
for i, idx in enumerate(idxs):
llocs = wh[1][locs[i] : locs[i + 1]]
split_locs = np.array(recursive_split_locs(llocs))
# check if they have both positive and negative going - messes with integration later
t = tc_filt[idx, :]
corr_locs = correct_event_signs(t, split_locs)
result[idx] = corr_locs.T
result["tc_filt"] = tc_filt
result["tc"] = tc
return result
def get_event_properties(event_dict, use_filt=True):
if use_filt:
t = event_dict["tc"]
else:
t = event_dict["tc_filt"]
result_dict = {}
for idx in event_dict.keys():
if type(idx) == str:
continue
event_properties = []
for locs in event_dict[idx].T:
if np.logical_and(
np.any(t[idx, locs[0] : locs[1]] - 1 > 0),
np.any(t[idx, locs[0] : locs[1]] - 1 < 0),
):
print(idx, locs)
raise ValueError("This shouldnt happen")
event_length = locs[1] - locs[0]
event_amplitude = (
t[idx, np.argmax(np.abs(t[idx, locs[0] : locs[1]] - 1)) + locs[0]] - 1
)
event_integrated = np.sum(t[idx, locs[0] : locs[1]] - 1)
event_properties.append([event_length, event_amplitude, event_integrated])
if len(np.array(event_properties)) == 0:
pdb.set_trace()
result_dict[idx] = np.array(event_properties)
event_dict["event_props"] = result_dict
return event_dict
def lab2masks(seg):
masks = []
for i in range(1, seg.max() + 1):
masks.append((seg == i).astype(int))
return | np.array(masks) | numpy.array |
import datetime as dt
from unittest import SkipTest
import numpy as np
from holoviews.core import NdOverlay
from holoviews.core.options import Cycle
from holoviews.core.util import pd
from holoviews.element import Points
from holoviews.streams import Stream
from .testplot import TestBokehPlot, bokeh_renderer
from ..utils import ParamLogStream
try:
from bokeh.models import FactorRange, LinearColorMapper, CategoricalColorMapper
from bokeh.models import Scatter
except:
pass
class TestPointPlot(TestBokehPlot):
def test_points_colormapping(self):
points = Points(np.random.rand(10, 4), vdims=['a', 'b']).opts(plot=dict(color_index=3))
self._test_colormapping(points, 3)
def test_points_colormapping_with_nonselection(self):
opts = dict(plot=dict(color_index=3),
style=dict(nonselection_color='red'))
points = Points(np.random.rand(10, 4), vdims=['a', 'b']).opts(**opts)
self._test_colormapping(points, 3)
def test_points_colormapping_categorical(self):
points = Points([(i, i*2, i*3, chr(65+i)) for i in range(10)],
vdims=['a', 'b']).opts(plot=dict(color_index='b'))
plot = bokeh_renderer.get_plot(points)
plot.initialize_plot()
cmapper = plot.handles['color_mapper']
self.assertIsInstance(cmapper, CategoricalColorMapper)
self.assertEqual(cmapper.factors, list(points['b']))
def test_points_color_selection_nonselection(self):
opts = dict(color='green', selection_color='red', nonselection_color='blue')
points = Points([(i, i*2, i*3, chr(65+i)) for i in range(10)],
vdims=['a', 'b']).opts(style=opts)
plot = bokeh_renderer.get_plot(points)
glyph_renderer = plot.handles['glyph_renderer']
self.assertEqual(glyph_renderer.glyph.fill_color, 'green')
self.assertEqual(glyph_renderer.glyph.line_color, 'green')
self.assertEqual(glyph_renderer.selection_glyph.fill_color, 'red')
self.assertEqual(glyph_renderer.selection_glyph.line_color, 'red')
self.assertEqual(glyph_renderer.nonselection_glyph.fill_color, 'blue')
self.assertEqual(glyph_renderer.nonselection_glyph.line_color, 'blue')
def test_points_alpha_selection_nonselection(self):
opts = dict(alpha=0.8, selection_alpha=1.0, nonselection_alpha=0.2)
points = Points([(i, i*2, i*3, chr(65+i)) for i in range(10)],
vdims=['a', 'b']).opts(style=opts)
plot = bokeh_renderer.get_plot(points)
glyph_renderer = plot.handles['glyph_renderer']
self.assertEqual(glyph_renderer.glyph.fill_alpha, 0.8)
self.assertEqual(glyph_renderer.glyph.line_alpha, 0.8)
self.assertEqual(glyph_renderer.selection_glyph.fill_alpha, 1)
self.assertEqual(glyph_renderer.selection_glyph.line_alpha, 1)
self.assertEqual(glyph_renderer.nonselection_glyph.fill_alpha, 0.2)
self.assertEqual(glyph_renderer.nonselection_glyph.line_alpha, 0.2)
def test_points_alpha_selection_partial(self):
opts = dict(selection_alpha=1.0, selection_fill_alpha=0.2)
points = Points([(i, i*2, i*3, chr(65+i)) for i in range(10)],
vdims=['a', 'b']).opts(style=opts)
plot = bokeh_renderer.get_plot(points)
glyph_renderer = plot.handles['glyph_renderer']
self.assertEqual(glyph_renderer.glyph.fill_alpha, 1.0)
self.assertEqual(glyph_renderer.glyph.line_alpha, 1.0)
self.assertEqual(glyph_renderer.selection_glyph.fill_alpha, 0.2)
self.assertEqual(glyph_renderer.selection_glyph.line_alpha, 1)
def test_batched_points(self):
overlay = NdOverlay({i: Points(np.arange(i)) for i in range(1, 100)})
plot = bokeh_renderer.get_plot(overlay)
extents = plot.get_extents(overlay, {})
self.assertEqual(extents, (0, 0, 98, 98))
def test_batched_points_size_and_color(self):
opts = {'NdOverlay': dict(plot=dict(legend_limit=0)),
'Points': dict(style=dict(size=Cycle(values=[1, 2])))}
overlay = NdOverlay({i: Points([(i, j) for j in range(2)])
for i in range(2)}).opts(opts)
plot = bokeh_renderer.get_plot(overlay).subplots[()]
size = np.array([1, 1, 2, 2])
color = np.array(['#30a2da', '#30a2da', '#fc4f30', '#fc4f30'],
dtype='<U7')
self.assertEqual(plot.handles['source'].data['color'], color)
self.assertEqual(plot.handles['source'].data['size'], size)
def test_batched_points_line_color_and_color(self):
opts = {'NdOverlay': dict(plot=dict(legend_limit=0)),
'Points': dict(style=dict(line_color=Cycle(values=['red', 'blue'])))}
overlay = NdOverlay({i: Points([(i, j) for j in range(2)])
for i in range(2)}).opts(opts)
plot = bokeh_renderer.get_plot(overlay).subplots[()]
line_color = np.array(['red', 'red', 'blue', 'blue'])
fill_color = np.array(['#30a2da', '#30a2da', '#fc4f30', '#fc4f30'],
dtype='<U7')
self.assertEqual(plot.handles['source'].data['fill_color'], fill_color)
self.assertEqual(plot.handles['source'].data['line_color'], line_color)
def test_batched_points_alpha_and_color(self):
opts = {'NdOverlay': dict(plot=dict(legend_limit=0)),
'Points': dict(style=dict(alpha=Cycle(values=[0.5, 1])))}
overlay = NdOverlay({i: Points([(i, j) for j in range(2)])
for i in range(2)}).opts(opts)
plot = bokeh_renderer.get_plot(overlay).subplots[()]
alpha = np.array([0.5, 0.5, 1., 1.])
color = np.array(['#30a2da', '#30a2da', '#fc4f30', '#fc4f30'],
dtype='<U7')
self.assertEqual(plot.handles['source'].data['alpha'], alpha)
self.assertEqual(plot.handles['source'].data['color'], color)
def test_batched_points_line_width_and_color(self):
opts = {'NdOverlay': dict(plot=dict(legend_limit=0)),
'Points': dict(style=dict(line_width=Cycle(values=[0.5, 1])))}
overlay = NdOverlay({i: Points([(i, j) for j in range(2)])
for i in range(2)}).opts(opts)
plot = bokeh_renderer.get_plot(overlay).subplots[()]
line_width = np.array([0.5, 0.5, 1., 1.])
color = np.array(['#30a2da', '#30a2da', '#fc4f30', '#fc4f30'],
dtype='<U7')
self.assertEqual(plot.handles['source'].data['line_width'], line_width)
self.assertEqual(plot.handles['source'].data['color'], color)
def test_points_overlay_datetime_hover(self):
if pd is None:
raise SkipTest("Test requires pandas")
obj = NdOverlay({i: Points((list(pd.date_range('2016-01-01', '2016-01-31')), range(31))) for i in range(5)},
kdims=['Test'])
opts = {'Points': {'tools': ['hover']}}
obj = obj.opts(plot=opts)
self._test_hover_info(obj, [('Test', '@{Test}'), ('x', '@{x_dt_strings}'), ('y', '@{y}')])
def test_points_overlay_hover_batched(self):
obj = NdOverlay({i: Points(np.random.rand(10,2)) for i in range(5)},
kdims=['Test'])
opts = {'Points': {'tools': ['hover']},
'NdOverlay': {'legend_limit': 0}}
obj = obj.opts(plot=opts)
self._test_hover_info(obj, [('Test', '@{Test}'), ('x', '@{x}'), ('y', '@{y}')])
def test_points_overlay_hover(self):
obj = NdOverlay({i: Points(np.random.rand(10,2)) for i in range(5)},
kdims=['Test'])
opts = {'Points': {'tools': ['hover']},
'NdOverlay': {'legend_limit': 0}}
obj = obj.opts(plot=opts)
self._test_hover_info(obj, [('Test', '@{Test}'), ('x', '@{x}'),
('y', '@{y}')])
def test_points_no_single_item_legend(self):
points = Points([('A', 1), ('B', 2)], label='A')
plot = bokeh_renderer.get_plot(points)
plot.initialize_plot()
fig = plot.state
self.assertEqual(len(fig.legend), 0)
def test_points_non_numeric_size_warning(self):
data = (np.arange(10), np.arange(10), list(map(chr, range(94,104))))
points = Points(data, vdims=['z']).opts(plot=dict(size_index=2))
with ParamLogStream() as log:
bokeh_renderer.get_plot(points)
log_msg = log.stream.read()
warning = ('z dimension is not numeric, '
'cannot use to scale Points size.\n')
self.assertEqual(log_msg, warning)
def test_points_categorical_xaxis(self):
points = Points((['A', 'B', 'C'], (1,2,3)))
plot = bokeh_renderer.get_plot(points)
x_range = plot.handles['x_range']
self.assertIsInstance(x_range, FactorRange)
self.assertEqual(x_range.factors, ['A', 'B', 'C'])
def test_points_categorical_xaxis_mixed_type(self):
points = Points(range(10))
points2 = Points((['A', 'B', 'C', 1, 2.0], (1, 2, 3, 4, 5)))
plot = bokeh_renderer.get_plot(points*points2)
x_range = plot.handles['x_range']
self.assertIsInstance(x_range, FactorRange)
self.assertEqual(x_range.factors, list(map(str, range(10))) + ['A', 'B', 'C', '2.0'])
def test_points_categorical_xaxis_invert_axes(self):
points = Points((['A', 'B', 'C'], (1,2,3))).opts(plot=dict(invert_axes=True))
plot = bokeh_renderer.get_plot(points)
y_range = plot.handles['y_range']
self.assertIsInstance(y_range, FactorRange)
self.assertEqual(y_range.factors, ['A', 'B', 'C'])
def test_points_overlay_categorical_xaxis(self):
points = Points((['A', 'B', 'C'], (1,2,3)))
points2 = Points((['B', 'C', 'D'], (1,2,3)))
plot = bokeh_renderer.get_plot(points*points2)
x_range = plot.handles['x_range']
self.assertIsInstance(x_range, FactorRange)
self.assertEqual(x_range.factors, ['A', 'B', 'C', 'D'])
def test_points_overlay_categorical_xaxis_invert_axis(self):
points = Points((['A', 'B', 'C'], (1,2,3))).opts(plot=dict(invert_xaxis=True))
points2 = Points((['B', 'C', 'D'], (1,2,3)))
plot = bokeh_renderer.get_plot(points*points2)
x_range = plot.handles['x_range']
self.assertIsInstance(x_range, FactorRange)
self.assertEqual(x_range.factors, ['A', 'B', 'C', 'D'][::-1])
def test_points_overlay_categorical_xaxis_invert_axes(self):
points = Points((['A', 'B', 'C'], (1,2,3))).opts(plot=dict(invert_axes=True))
points2 = Points((['B', 'C', 'D'], (1,2,3)))
plot = bokeh_renderer.get_plot(points*points2)
y_range = plot.handles['y_range']
self.assertIsInstance(y_range, FactorRange)
self.assertEqual(y_range.factors, ['A', 'B', 'C', 'D'])
def test_points_padding_square(self):
points = Points([1, 2, 3]).options(padding=0.1)
plot = bokeh_renderer.get_plot(points)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, -0.2)
self.assertEqual(x_range.end, 2.2)
self.assertEqual(y_range.start, 0.8)
self.assertEqual(y_range.end, 3.2)
def test_curve_padding_square_per_axis(self):
curve = Points([1, 2, 3]).options(padding=((0, 0.1), (0.1, 0.2)))
plot = bokeh_renderer.get_plot(curve)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, 0)
self.assertEqual(x_range.end, 2.2)
self.assertEqual(y_range.start, 0.8)
self.assertEqual(y_range.end, 3.4)
def test_points_padding_unequal(self):
points = Points([1, 2, 3]).options(padding=(0.05, 0.1))
plot = bokeh_renderer.get_plot(points)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, -0.1)
self.assertEqual(x_range.end, 2.1)
self.assertEqual(y_range.start, 0.8)
self.assertEqual(y_range.end, 3.2)
def test_points_padding_nonsquare(self):
points = Points([1, 2, 3]).options(padding=0.1, width=600)
plot = bokeh_renderer.get_plot(points)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, -0.1)
self.assertEqual(x_range.end, 2.1)
self.assertEqual(y_range.start, 0.8)
self.assertEqual(y_range.end, 3.2)
def test_points_padding_logx(self):
points = Points([(1, 1), (2, 2), (3,3)]).options(padding=0.1, logx=True)
plot = bokeh_renderer.get_plot(points)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, 0.89595845984076228)
self.assertEqual(x_range.end, 3.3483695221017129)
self.assertEqual(y_range.start, 0.8)
self.assertEqual(y_range.end, 3.2)
def test_points_padding_logy(self):
points = Points([1, 2, 3]).options(padding=0.1, logy=True)
plot = bokeh_renderer.get_plot(points)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, -0.2)
self.assertEqual(x_range.end, 2.2)
self.assertEqual(y_range.start, 0.89595845984076228)
self.assertEqual(y_range.end, 3.3483695221017129)
def test_points_padding_datetime_square(self):
points = Points([(np.datetime64('2016-04-0%d' % i), i) for i in range(1, 4)]).options(
padding=0.1
)
plot = bokeh_renderer.get_plot(points)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, np.datetime64('2016-03-31T19:12:00.000000000'))
self.assertEqual(x_range.end, np.datetime64('2016-04-03T04:48:00.000000000'))
self.assertEqual(y_range.start, 0.8)
self.assertEqual(y_range.end, 3.2)
def test_points_padding_datetime_nonsquare(self):
points = Points([(np.datetime64('2016-04-0%d' % i), i) for i in range(1, 4)]).options(
padding=0.1, width=600
)
plot = bokeh_renderer.get_plot(points)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, np.datetime64('2016-03-31T21:36:00.000000000'))
self.assertEqual(x_range.end, np.datetime64('2016-04-03T02:24:00.000000000'))
self.assertEqual(y_range.start, 0.8)
self.assertEqual(y_range.end, 3.2)
def test_points_padding_hard_xrange(self):
points = Points([1, 2, 3]).redim.range(x=(0, 3)).options(padding=0.1)
plot = bokeh_renderer.get_plot(points)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, 0)
self.assertEqual(x_range.end, 3)
self.assertEqual(y_range.start, 0.8)
self.assertEqual(y_range.end, 3.2)
def test_points_padding_soft_xrange(self):
points = Points([1, 2, 3]).redim.soft_range(x=(0, 3)).options(padding=0.1)
plot = bokeh_renderer.get_plot(points)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, 0)
self.assertEqual(x_range.end, 3)
self.assertEqual(y_range.start, 0.8)
self.assertEqual(y_range.end, 3.2)
def test_points_datetime_hover(self):
points = Points([(0, 1, dt.datetime(2017, 1, 1))], vdims='date').options(tools=['hover'])
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
self.assertEqual(cds.data['date'].astype('datetime64'), np.array([1483228800000000000]))
self.assertEqual(cds.data['date_dt_strings'], ['2017-01-01 00:00:00'])
hover = plot.handles['hover']
self.assertEqual(hover.tooltips, [('x', '@{x}'), ('y', '@{y}'), ('date', '@{date_dt_strings}')])
def test_points_selected(self):
points = Points([(0, 0), (1, 1), (2, 2)]).opts(selected=[0, 2])
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
self.assertEqual(cds.selected.indices, [0, 2])
def test_points_update_selected(self):
stream = Stream.define('Selected', selected=[])()
points = Points([(0, 0), (1, 1), (2, 2)]).apply.opts(selected=stream.param.selected)
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
self.assertEqual(cds.selected.indices, [])
stream.event(selected=[0, 2])
self.assertEqual(cds.selected.indices, [0, 2])
###########################
# Styling mapping #
###########################
def test_point_color_op(self):
points = Points([(0, 0, '#000'), (0, 1, '#F00'), (0, 2, '#0F0')],
vdims='color').options(color='color')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['color'], np.array(['#000', '#F00', '#0F0']))
self.assertEqual(glyph.fill_color, {'field': 'color'})
self.assertEqual(glyph.line_color, {'field': 'color'})
def test_point_linear_color_op(self):
points = Points([(0, 0, 0), (0, 1, 1), (0, 2, 2)],
vdims='color').options(color='color')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
cmapper = plot.handles['color_color_mapper']
self.assertTrue(cmapper, LinearColorMapper)
self.assertEqual(cmapper.low, 0)
self.assertEqual(cmapper.high, 2)
self.assertEqual(cds.data['color'], np.array([0, 1, 2]))
self.assertEqual(glyph.fill_color, {'field': 'color', 'transform': cmapper})
self.assertEqual(glyph.line_color, {'field': 'color', 'transform': cmapper})
def test_point_categorical_color_op(self):
points = Points([(0, 0, 'A'), (0, 1, 'B'), (0, 2, 'C')],
vdims='color').options(color='color')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
cmapper = plot.handles['color_color_mapper']
self.assertTrue(cmapper, CategoricalColorMapper)
self.assertEqual(cmapper.factors, ['A', 'B', 'C'])
self.assertEqual(cds.data['color'], np.array(['A', 'B', 'C']))
self.assertEqual(glyph.fill_color, {'field': 'color', 'transform': cmapper})
self.assertEqual(glyph.line_color, {'field': 'color', 'transform': cmapper})
def test_point_categorical_dtype_color_op(self):
df = pd.DataFrame(dict(sample_id=['subject 1', 'subject 2', 'subject 3', 'subject 4'], category=['apple', 'pear', 'apple', 'pear'], value=[1, 2, 3, 4]))
df['category'] = df['category'].astype('category')
points = Points(df, ['sample_id', 'value']).opts(color='category')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
cmapper = plot.handles['color_color_mapper']
self.assertTrue(cmapper, CategoricalColorMapper)
self.assertEqual(cmapper.factors, ['apple', 'pear'])
self.assertEqual(np.asarray(cds.data['color']), np.array(['apple', 'pear', 'apple', 'pear']))
self.assertEqual(glyph.fill_color, {'field': 'color', 'transform': cmapper})
self.assertEqual(glyph.line_color, {'field': 'color', 'transform': cmapper})
def test_point_explicit_cmap_color_op(self):
points = Points([(0, 0), (0, 1), (0, 2)]).options(
color='y', cmap={0: 'red', 1: 'green', 2: 'blue'})
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
cmapper = plot.handles['color_color_mapper']
self.assertTrue(cmapper, CategoricalColorMapper)
self.assertEqual(cmapper.factors, ['0', '1', '2'])
self.assertEqual(cmapper.palette, ['red', 'green', 'blue'])
self.assertEqual(cds.data['color_str__'], ['0', '1', '2'])
self.assertEqual(glyph.fill_color, {'field': 'color_str__', 'transform': cmapper})
self.assertEqual(glyph.line_color, {'field': 'color_str__', 'transform': cmapper})
def test_point_line_color_op(self):
points = Points([(0, 0, '#000'), (0, 1, '#F00'), (0, 2, '#0F0')],
vdims='color').options(line_color='color')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['line_color'], np.array(['#000', '#F00', '#0F0']))
self.assertNotEqual(glyph.fill_color, {'field': 'line_color'})
self.assertEqual(glyph.line_color, {'field': 'line_color'})
def test_point_fill_color_op(self):
points = Points([(0, 0, '#000'), (0, 1, '#F00'), (0, 2, '#0F0')],
vdims='color').options(fill_color='color')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['fill_color'], np.array(['#000', '#F00', '#0F0']))
self.assertEqual(glyph.fill_color, {'field': 'fill_color'})
self.assertNotEqual(glyph.line_color, {'field': 'fill_color'})
def test_point_angle_op(self):
points = Points([(0, 0, 0), (0, 1, 45), (0, 2, 90)],
vdims='angle').options(angle='angle')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['angle'], np.array([0, 0.785398, 1.570796]))
self.assertEqual(glyph.angle, {'field': 'angle'})
def test_point_alpha_op(self):
points = Points([(0, 0, 0), (0, 1, 0.2), (0, 2, 0.7)],
vdims='alpha').options(alpha='alpha')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['alpha'], np.array([0, 0.2, 0.7]))
self.assertEqual(glyph.fill_alpha, {'field': 'alpha'})
def test_point_line_alpha_op(self):
points = Points([(0, 0, 0), (0, 1, 0.2), (0, 2, 0.7)],
vdims='alpha').options(line_alpha='alpha')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['line_alpha'], np.array([0, 0.2, 0.7]))
self.assertEqual(glyph.line_alpha, {'field': 'line_alpha'})
self.assertNotEqual(glyph.fill_alpha, {'field': 'line_alpha'})
def test_point_fill_alpha_op(self):
points = Points([(0, 0, 0), (0, 1, 0.2), (0, 2, 0.7)],
vdims='alpha').options(fill_alpha='alpha')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['fill_alpha'], np.array([0, 0.2, 0.7]))
self.assertNotEqual(glyph.line_alpha, {'field': 'fill_alpha'})
self.assertEqual(glyph.fill_alpha, {'field': 'fill_alpha'})
def test_point_size_op(self):
points = Points([(0, 0, 1), (0, 1, 4), (0, 2, 8)],
vdims='size').options(size='size')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['size'], np.array([1, 4, 8]))
self.assertEqual(glyph.size, {'field': 'size'})
def test_point_line_width_op(self):
points = Points([(0, 0, 1), (0, 1, 4), (0, 2, 8)],
vdims='line_width').options(line_width='line_width')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['line_width'], np.array([1, 4, 8]))
self.assertEqual(glyph.line_width, {'field': 'line_width'})
def test_point_marker_op(self):
points = Points([(0, 0, 'circle'), (0, 1, 'triangle'), (0, 2, 'square')],
vdims='marker').options(marker='marker')
plot = bokeh_renderer.get_plot(points)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['marker'], | np.array(['circle', 'triangle', 'square']) | numpy.array |
import lmfit
import numpy as np
from numpy.linalg import inv
import scipy as sp
import itertools
import matplotlib as mpl
from collections import OrderedDict, defaultdict
from pycqed.utilities import timer as tm_mod
from sklearn.mixture import GaussianMixture as GM
from sklearn.tree import DecisionTreeClassifier as DTC
from pycqed.analysis import fitting_models as fit_mods
from pycqed.analysis import analysis_toolbox as a_tools
import pycqed.analysis_v2.base_analysis as ba
import pycqed.analysis_v2.readout_analysis as roa
from pycqed.analysis_v2.readout_analysis import \
Singleshot_Readout_Analysis_Qutrit as SSROQutrit
import pycqed.analysis_v2.tomography_qudev as tomo
from pycqed.analysis.tools.plotting import SI_val_to_msg_str
from copy import deepcopy
from pycqed.measurement.sweep_points import SweepPoints
from pycqed.measurement.calibration.calibration_points import CalibrationPoints
import matplotlib.pyplot as plt
from pycqed.analysis.three_state_rotation import predict_proba_avg_ro
import logging
from pycqed.utilities import math
from pycqed.utilities.general import find_symmetry_index
import pycqed.measurement.waveform_control.segment as seg_mod
import datetime as dt
log = logging.getLogger(__name__)
try:
import qutip as qtp
except ImportError as e:
log.warning('Could not import qutip, tomography code will not work')
class AveragedTimedomainAnalysis(ba.BaseDataAnalysis):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.single_timestamp = True
self.params_dict = {
'value_names': 'value_names',
'measured_values': 'measured_values',
'measurementstring': 'measurementstring',
'exp_metadata': 'exp_metadata'}
self.numeric_params = []
if kwargs.get('auto', True):
self.run_analysis()
def process_data(self):
self.metadata = self.raw_data_dict.get('exp_metadata', {})
if self.metadata is None:
self.metadata = {}
cal_points = self.metadata.get('cal_points', None)
cal_points = self.options_dict.get('cal_points', cal_points)
cal_points_list = roa.convert_channel_names_to_index(
cal_points, len(self.raw_data_dict['measured_values'][0]),
self.raw_data_dict['value_names'])
self.proc_data_dict['cal_points_list'] = cal_points_list
measured_values = self.raw_data_dict['measured_values']
cal_idxs = self._find_calibration_indices()
scales = [np.std(x[cal_idxs]) for x in measured_values]
observable_vectors = np.zeros((len(cal_points_list),
len(measured_values)))
observable_vector_stds = np.ones_like(observable_vectors)
for i, observable in enumerate(cal_points_list):
for ch_idx, seg_idxs in enumerate(observable):
x = measured_values[ch_idx][seg_idxs] / scales[ch_idx]
if len(x) > 0:
observable_vectors[i][ch_idx] = np.mean(x)
if len(x) > 1:
observable_vector_stds[i][ch_idx] = np.std(x)
Omtx = (observable_vectors[1:] - observable_vectors[0]).T
d0 = observable_vectors[0]
corr_values = np.zeros(
(len(cal_points_list) - 1, len(measured_values[0])))
for i in range(len(measured_values[0])):
d = np.array([x[i] / scale for x, scale in zip(measured_values,
scales)])
corr_values[:, i] = inv(Omtx.T.dot(Omtx)).dot(Omtx.T).dot(d - d0)
self.proc_data_dict['corr_values'] = corr_values
def measurement_operators_and_results(self):
"""
Converts the calibration points to measurement operators. Assumes that
the calibration points are ordered the same as the basis states for
the tomography calculation (e.g. for two qubits |gg>, |ge>, |eg>, |ee>).
Also assumes that each calibration in the passed cal_points uses
different segments.
Returns:
A tuple of
the measured values with outthe calibration points;
the measurement operators corresponding to each channel;
and the expected covariation matrix between the operators.
"""
d = len(self.proc_data_dict['cal_points_list'])
cal_point_idxs = [set() for _ in range(d)]
for i, idxs_lists in enumerate(self.proc_data_dict['cal_points_list']):
for idxs in idxs_lists:
cal_point_idxs[i].update(idxs)
cal_point_idxs = [sorted(list(idxs)) for idxs in cal_point_idxs]
cal_point_idxs = np.array(cal_point_idxs)
raw_data = self.raw_data_dict['measured_values']
means = [None] * d
residuals = [list() for _ in raw_data]
for i, cal_point_idx in enumerate(cal_point_idxs):
means[i] = [np.mean(ch_data[cal_point_idx]) for ch_data in raw_data]
for j, ch_residuals in enumerate(residuals):
ch_residuals += list(raw_data[j][cal_point_idx] - means[i][j])
means = np.array(means)
residuals = np.array(residuals)
Fs = [np.diag(ms) for ms in means.T]
Omega = residuals.dot(residuals.T) / len(residuals.T)
data_idxs = np.setdiff1d(np.arange(len(raw_data[0])),
cal_point_idxs.flatten())
data = np.array([ch_data[data_idxs] for ch_data in raw_data])
return data, Fs, Omega
def _find_calibration_indices(self):
cal_indices = set()
cal_points = self.options_dict['cal_points']
nr_segments = self.raw_data_dict['measured_values'].shape[-1]
for observable in cal_points:
if isinstance(observable, (list, np.ndarray)):
for idxs in observable:
cal_indices.update({idx % nr_segments for idx in idxs})
else: # assume dictionaries
for idxs in observable.values():
cal_indices.update({idx % nr_segments for idx in idxs})
return list(cal_indices)
def all_cal_points(d, nr_ch, reps=1):
"""
Generates a list of calibration points for a Hilbert space of dimension d,
with nr_ch channels and reps reprtitions of each calibration point.
"""
return [[list(range(-reps*i, -reps*(i-1)))]*nr_ch for i in range(d, 0, -1)]
class Single_Qubit_TimeDomainAnalysis(ba.BaseDataAnalysis):
def process_data(self):
"""
This takes care of rotating and normalizing the data if required.
this should work for several input types.
- I/Q values (2 quadratures + cal points)
- weight functions (1 quadrature + cal points)
- counts (no cal points)
There are several options possible to specify the normalization
using the options dict.
cal_points (tuple) of indices of the calibrati on points
zero_coord, one_coord
"""
cal_points = self.options_dict.get('cal_points', None)
zero_coord = self.options_dict.get('zero_coord', None)
one_coord = self.options_dict.get('one_coord', None)
if cal_points is None:
# default for all standard Timedomain experiments
cal_points = [list(range(-4, -2)), list(range(-2, 0))]
if len(self.raw_data_dict['measured_values']) == 1:
# if only one weight function is used rotation is not required
self.proc_data_dict['corr_data'] = a_tools.rotate_and_normalize_data_1ch(
self.raw_data_dict['measured_values'][0],
cal_zero_points=cal_points[0],
cal_one_points=cal_points[1])
else:
self.proc_data_dict['corr_data'], zero_coord, one_coord = \
a_tools.rotate_and_normalize_data(
data=self.raw_data_dict['measured_values'][0:2],
zero_coord=zero_coord,
one_coord=one_coord,
cal_zero_points=cal_points[0],
cal_one_points=cal_points[1])
# This should be added to the hdf5 datafile but cannot because of the
# way that the "new" analysis works.
# self.add_dataset_to_analysisgroup('Corrected data',
# self.proc_data_dict['corr_data'])
class MultiQubit_TimeDomain_Analysis(ba.BaseDataAnalysis):
"""
Base class for multi-qubit time-domain analyses.
Parameters that can be specified in the options dict:
- rotation_type: type of rotation to be done on the raw data.
Types of rotations supported by this class:
- 'cal_states' (default, no need to specify): rotation based on
CalibrationPoints for 1D and TwoD data. Supports 2 and 3 cal states
per qubit
- 'fixed_cal_points' (only for TwoD, with 2 cal states):
does PCA on the columns corresponding to the highest cal state
to find the indices of that cal state in the columns, then uses
those to get the data points for the other cal state. Does
rotation using the mean of the data points corresponding to the
two cal states as the zero and one coordinates to rotate
the data.
- 'PCA': ignores cal points and does pca; in the case of TwoD data it
does PCA row by row
- 'column_PCA': cal points and does pca; in the case of TwoD data it
does PCA column by column
- 'global_PCA' (only for TwoD): does PCA on the whole 2D array
- main_sp (default: None): dict with keys qb_name used to specify which
sweep parameter should be used as axis label in plot
- functionality to split measurements with tiled sweep_points:
- split_params (default: None): list of strings with sweep parameters
names expected to be found in SweepPoints. Groups data by these
parameters and stores it in proc_data_dict['split_data_dict'].
- select_split (default: None): dict with keys qb_names and values
a tuple (sweep_param_name, value) or (sweep_param_name, index).
Stored in self.measurement_strings which specify the plot title.
The selected parameter must also be part of the split_params for
that qubit.
"""
def __init__(self,
qb_names: list=None, label: str='',
t_start: str=None, t_stop: str=None, data_file_path: str=None,
options_dict: dict=None, extract_only: bool=False,
do_fitting: bool=True, auto=True,
params_dict=None, numeric_params=None, **kwargs):
super().__init__(t_start=t_start, t_stop=t_stop, label=label,
data_file_path=data_file_path,
options_dict=options_dict,
extract_only=extract_only,
do_fitting=do_fitting, **kwargs)
self.qb_names = qb_names
self.params_dict = params_dict
if self.params_dict is None:
self.params_dict = {}
self.numeric_params = numeric_params
self.measurement_strings = {}
if self.numeric_params is None:
self.numeric_params = []
if not hasattr(self, "job"):
self.create_job(qb_names=qb_names, t_start=t_start, t_stop=t_stop,
label=label, data_file_path=data_file_path,
do_fitting=do_fitting, options_dict=options_dict,
extract_only=extract_only, params_dict=params_dict,
numeric_params=numeric_params, **kwargs)
if auto:
self.run_analysis()
def extract_data(self):
super().extract_data()
if self.qb_names is None:
self.qb_names = self.get_param_value('ro_qubits')
if self.qb_names is None:
raise ValueError('Provide the "qb_names."')
self.measurement_strings = {
qbn: self.raw_data_dict['measurementstring'] for qbn in
self.qb_names}
self.channel_map = self.get_param_value('meas_obj_value_names_map')
if self.channel_map is None:
# if the new name meas_obj_value_names_map is not found, try with
# the old name channel_map
self.channel_map = self.get_param_value('channel_map')
if self.channel_map is None:
value_names = self.raw_data_dict['value_names']
if np.ndim(value_names) > 0:
value_names = value_names
if 'w' in value_names[0]:
self.channel_map = a_tools.get_qb_channel_map_from_hdf(
self.qb_names, value_names=value_names,
file_path=self.raw_data_dict['folder'])
else:
self.channel_map = {}
for qbn in self.qb_names:
self.channel_map[qbn] = value_names
if len(self.channel_map) == 0:
raise ValueError('No qubit RO channels have been found.')
# creates self.sp
self.get_sweep_points()
def get_sweep_points(self):
self.sp = self.get_param_value('sweep_points')
if self.sp is not None:
self.sp = SweepPoints(self.sp)
def create_sweep_points_dict(self):
sweep_points_dict = self.get_param_value('sweep_points_dict')
hard_sweep_params = self.get_param_value('hard_sweep_params')
if self.sp is not None:
self.mospm = self.get_param_value('meas_obj_sweep_points_map')
main_sp = self.get_param_value('main_sp')
if self.mospm is None:
raise ValueError('When providing "sweep_points", '
'"meas_obj_sweep_points_map" has to be '
'provided in addition.')
if main_sp is not None:
self.proc_data_dict['sweep_points_dict'] = {}
for qbn, p in main_sp.items():
dim = self.sp.find_parameter(p)
if dim == 1:
log.warning(f"main_sp is only implemented for sweep "
f"dimension 0, but {p} is in dimension 1.")
self.proc_data_dict['sweep_points_dict'][qbn] = \
{'sweep_points': self.sp.get_sweep_params_property(
'values', dim, p)}
else:
self.proc_data_dict['sweep_points_dict'] = \
{qbn: {'sweep_points': self.sp.get_sweep_params_property(
'values', 0, self.mospm[qbn])[0]}
for qbn in self.qb_names}
elif sweep_points_dict is not None:
# assumed to be of the form {qbn1: swpts_array1, qbn2: swpts_array2}
self.proc_data_dict['sweep_points_dict'] = \
{qbn: {'sweep_points': sweep_points_dict[qbn]}
for qbn in self.qb_names}
elif hard_sweep_params is not None:
self.proc_data_dict['sweep_points_dict'] = \
{qbn: {'sweep_points': list(hard_sweep_params.values())[0][
'values']} for qbn in self.qb_names}
else:
self.proc_data_dict['sweep_points_dict'] = \
{qbn: {'sweep_points': self.data_filter(
self.raw_data_dict['hard_sweep_points'])}
for qbn in self.qb_names}
def create_sweep_points_2D_dict(self):
soft_sweep_params = self.get_param_value('soft_sweep_params')
if self.sp is not None:
self.proc_data_dict['sweep_points_2D_dict'] = OrderedDict()
for qbn in self.qb_names:
self.proc_data_dict['sweep_points_2D_dict'][qbn] = \
OrderedDict()
for pn in self.mospm[qbn]:
if pn in self.sp[1]:
self.proc_data_dict['sweep_points_2D_dict'][qbn][
pn] = self.sp[1][pn][0]
elif soft_sweep_params is not None:
self.proc_data_dict['sweep_points_2D_dict'] = \
{qbn: {pn: soft_sweep_params[pn]['values'] for
pn in soft_sweep_params}
for qbn in self.qb_names}
else:
if len(self.raw_data_dict['soft_sweep_points'].shape) == 1:
self.proc_data_dict['sweep_points_2D_dict'] = \
{qbn: {self.raw_data_dict['sweep_parameter_names'][1]:
self.raw_data_dict['soft_sweep_points']} for
qbn in self.qb_names}
else:
sspn = self.raw_data_dict['sweep_parameter_names'][1:]
self.proc_data_dict['sweep_points_2D_dict'] = \
{qbn: {sspn[i]: self.raw_data_dict['soft_sweep_points'][i]
for i in range(len(sspn))} for qbn in self.qb_names}
if self.get_param_value('percentage_done', 100) < 100:
# This indicated an interrupted measurement.
# Remove non-measured sweep points in that case.
# raw_data_dict['soft_sweep_points'] is obtained in
# BaseDataAnalysis.add_measured_data(), and its length should
# always correspond to the actual number of measured soft sweep
# points.
ssl = len(self.raw_data_dict['soft_sweep_points'])
for sps in self.proc_data_dict['sweep_points_2D_dict'].values():
for k, v in sps.items():
sps[k] = v[:ssl]
def create_meas_results_per_qb(self):
measured_RO_channels = list(self.raw_data_dict['measured_data'])
meas_results_per_qb_raw = {}
meas_results_per_qb = {}
for qb_name, RO_channels in self.channel_map.items():
meas_results_per_qb_raw[qb_name] = {}
meas_results_per_qb[qb_name] = {}
if isinstance(RO_channels, str):
meas_ROs_per_qb = [RO_ch for RO_ch in measured_RO_channels
if RO_channels in RO_ch]
for meas_RO in meas_ROs_per_qb:
meas_results_per_qb_raw[qb_name][meas_RO] = \
self.raw_data_dict[
'measured_data'][meas_RO]
meas_results_per_qb[qb_name][meas_RO] = \
self.data_filter(
meas_results_per_qb_raw[qb_name][meas_RO])
elif isinstance(RO_channels, list):
for qb_RO_ch in RO_channels:
meas_ROs_per_qb = [RO_ch for RO_ch in measured_RO_channels
if qb_RO_ch in RO_ch]
for meas_RO in meas_ROs_per_qb:
meas_results_per_qb_raw[qb_name][meas_RO] = \
self.raw_data_dict[
'measured_data'][meas_RO]
meas_results_per_qb[qb_name][meas_RO] = \
self.data_filter(
meas_results_per_qb_raw[qb_name][meas_RO])
else:
raise TypeError('The RO channels for {} must either be a list '
'or a string.'.format(qb_name))
self.proc_data_dict['meas_results_per_qb_raw'] = \
meas_results_per_qb_raw
self.proc_data_dict['meas_results_per_qb'] = \
meas_results_per_qb
def process_data(self):
super().process_data()
self.data_filter = self.get_param_value('data_filter')
prep_params = self.get_param_value('preparation_params',
default_value=dict())
self.data_with_reset = False
if self.data_filter is None:
if 'active' in prep_params.get('preparation_type', 'wait'):
reset_reps = prep_params.get('reset_reps', 1)
self.data_filter = lambda x: x[reset_reps::reset_reps+1]
self.data_with_reset = True
elif "preselection" in prep_params.get('preparation_type', 'wait'):
self.data_filter = lambda x: x[1::2] # filter preselection RO
if self.data_filter is None:
self.data_filter = lambda x: x
self.create_sweep_points_dict()
self.create_meas_results_per_qb()
# temporary fix for appending calibration points to x values but
# without breaking sequences not yet using this interface.
self.rotate = self.get_param_value('rotate', default_value=False)
cal_points = self.get_param_value('cal_points')
last_ge_pulses = self.get_param_value('last_ge_pulses',
default_value=False)
try:
self.cp = CalibrationPoints.from_string(cal_points)
# for now assuming the same for all qubits.
self.cal_states_dict = self.cp.get_indices(
self.qb_names, prep_params)[self.qb_names[0]]
cal_states_rots = self.cp.get_rotations(last_ge_pulses,
self.qb_names[0])[self.qb_names[0]] if self.rotate \
else None
self.cal_states_rotations = self.get_param_value(
'cal_states_rotations', default_value=cal_states_rots)
sweep_points_w_calpts = \
{qbn: {'sweep_points': self.cp.extend_sweep_points(
self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'], qbn)} for qbn in self.qb_names}
self.proc_data_dict['sweep_points_dict'] = sweep_points_w_calpts
except TypeError as e:
log.error(e)
log.warning("Failed retrieving cal point objects or states. "
"Please update measurement to provide cal point object "
"in metadata. Trying to get them using the old way ...")
self.cal_states_rotations = self.get_param_value(
'cal_states_rotations', default_value=None) \
if self.rotate else None
self.cal_states_dict = self.get_param_value('cal_states_dict',
default_value={})
if self.get_param_value('global_PCA') is not None:
log.warning('Parameter "global_PCA" is deprecated. Please set '
'rotation_type="global_PCA" instead.')
self.rotation_type = self.get_param_value(
'rotation_type',
default_value='cal_states' if self.rotate else 'no_rotation')
# create projected_data_dict
self.data_to_fit = deepcopy(self.get_param_value('data_to_fit'))
if self.data_to_fit is None:
# If we have cal points, but data_to_fit is not specified,
# choose a reasonable default value. In cases with only two cal
# points, this decides which projected plot is generated. (In
# cases with three cal points, we will anyways get all three
# projected plots.)
if 'e' in self.cal_states_dict.keys():
self.data_to_fit = {qbn: 'pe' for qbn in self.qb_names}
elif 'g' in self.cal_states_dict.keys():
self.data_to_fit = {qbn: 'pg' for qbn in self.qb_names}
else:
self.data_to_fit = {}
# TODO: Steph 15.09.2020
# This is a hack to allow list inside data_to_fit. These lists are
# currently only supported by MultiCZgate_CalibAnalysis
for qbn in self.data_to_fit:
if isinstance(self.data_to_fit[qbn], (list, tuple)):
self.data_to_fit[qbn] = self.data_to_fit[qbn][0]
if self.rotate or self.rotation_type == 'global_PCA':
self.cal_states_analysis()
else:
# this assumes data obtained with classifier detector!
# ie pg, pe, pf are expected to be in the value_names
self.proc_data_dict['projected_data_dict'] = OrderedDict()
for qbn, data_dict in self.proc_data_dict[
'meas_results_per_qb'].items():
self.proc_data_dict['projected_data_dict'][qbn] = OrderedDict()
for state_prob in ['pg', 'pe', 'pf']:
self.proc_data_dict['projected_data_dict'][qbn].update(
{state_prob: data for key, data in data_dict.items()
if state_prob in key})
if self.cal_states_dict is None:
self.cal_states_dict = {}
self.num_cal_points = np.array(list(
self.cal_states_dict.values())).flatten().size
# correct probabilities given calibration matrix
if self.get_param_value("correction_matrix") is not None:
self.proc_data_dict['projected_data_dict_corrected'] = OrderedDict()
for qbn, data_dict in self.proc_data_dict[
'meas_results_per_qb'].items():
self.proc_data_dict['projected_data_dict'][qbn] = OrderedDict()
probas_raw = np.asarray([data_dict[k] for k in data_dict
for state_prob in ['pg', 'pe', 'pf'] if
state_prob in k])
corr_mtx = self.get_param_value("correction_matrix")[qbn]
probas_corrected = np.linalg.inv(corr_mtx).T @ probas_raw
for state_prob in ['pg', 'pe', 'pf']:
self.proc_data_dict['projected_data_dict_corrected'][qbn].update(
{state_prob: data for key, data in
zip(["pg", "pe", "pf"], probas_corrected)})
# get data_to_fit
self.proc_data_dict['data_to_fit'] = OrderedDict()
for qbn, prob_data in self.proc_data_dict[
'projected_data_dict'].items():
if qbn in self.data_to_fit:
self.proc_data_dict['data_to_fit'][qbn] = prob_data[
self.data_to_fit[qbn]]
# create msmt_sweep_points, sweep_points, cal_points_sweep_points
for qbn in self.qb_names:
if self.num_cal_points > 0:
self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points'] = \
self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'][:-self.num_cal_points]
self.proc_data_dict['sweep_points_dict'][qbn][
'cal_points_sweep_points'] = \
self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'][-self.num_cal_points::]
else:
self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points'] = self.proc_data_dict[
'sweep_points_dict'][qbn]['sweep_points']
self.proc_data_dict['sweep_points_dict'][qbn][
'cal_points_sweep_points'] = []
if self.options_dict.get('TwoD', False):
self.create_sweep_points_2D_dict()
# handle data splitting if needed
self.split_data()
def split_data(self):
def unique(l):
try:
return np.unique(l, return_inverse=True)
except Exception:
h = [repr(a) for a in l]
_, i, j = np.unique(h, return_index=True, return_inverse=True)
return l[i], j
split_params = self.get_param_value('split_params', [])
if not len(split_params):
return
pdd = self.proc_data_dict
pdd['split_data_dict'] = {}
for qbn in self.qb_names:
pdd['split_data_dict'][qbn] = {}
for p in split_params:
dim = self.sp.find_parameter(p)
sv = self.sp.get_sweep_params_property(
'values', param_names=p, dimension=dim)
usp, ind = unique(sv)
if len(usp) <= 1:
continue
svs = [self.sp.subset(ind == i, dim) for i in
range(len(usp))]
[s.remove_sweep_parameter(p) for s in svs]
sdd = {}
pdd['split_data_dict'][qbn][p] = sdd
for i in range(len(usp)):
subset = (np.concatenate(
[ind == i,
[True] * len(pdd['sweep_points_dict'][qbn][
'cal_points_sweep_points'])]))
sdd[i] = {}
sdd[i]['value'] = usp[i]
sdd[i]['sweep_points'] = svs[i]
d = pdd['sweep_points_dict'][qbn]
if dim == 0:
sdd[i]['sweep_points_dict'] = {
'sweep_points': d['sweep_points'][subset],
'msmt_sweep_points':
d['msmt_sweep_points'][ind == i],
'cal_points_sweep_points':
d['cal_points_sweep_points'],
}
sdd[i]['sweep_points_2D_dict'] = pdd[
'sweep_points_2D_dict'][qbn]
else:
sdd[i]['sweep_points_dict'] = \
pdd['sweep_points_dict'][qbn]
sdd[i]['sweep_points_2D_dict'] = {
k: v[ind == i] for k, v in pdd[
'sweep_points_2D_dict'][qbn].items()}
for d in ['projected_data_dict', 'data_to_fit']:
if isinstance(pdd[d][qbn], dict):
if dim == 0:
sdd[i][d] = {k: v[:, subset] for
k, v in pdd[d][qbn].items()}
else:
sdd[i][d] = {k: v[ind == i, :] for
k, v in pdd[d][qbn].items()}
else:
if dim == 0:
sdd[i][d] = pdd[d][qbn][:, subset]
else:
sdd[i][d] = pdd[d][qbn][ind == i, :]
select_split = self.get_param_value('select_split')
if select_split is not None:
for qbn, select in select_split.items():
p, v = select
if p not in pdd['split_data_dict'][qbn]:
log.warning(f"Split parameter {p} for {qbn} not "
f"found. Ignoring this selection.")
try:
ind = [a['value'] for a in pdd['split_data_dict'][
qbn][p].values()].index(v)
except ValueError:
ind = v
try:
pdd['split_data_dict'][qbn][p][ind]
except ValueError:
log.warning(f"Value {v} for split parameter {p} "
f"of {qbn} not found. Ignoring this "
f"selection.")
continue
for d in ['projected_data_dict', 'data_to_fit',
'sweep_points_dict', 'sweep_points_2D_dict']:
pdd[d][qbn] = pdd['split_data_dict'][qbn][p][ind][d]
self.measurement_strings[qbn] += f' ({p}: {v})'
def get_cal_data_points(self):
self.num_cal_points = np.array(list(
self.cal_states_dict.values())).flatten().size
do_PCA = self.rotation_type == 'PCA' or \
self.rotation_type == 'column_PCA'
self.cal_states_dict_for_rotation = OrderedDict()
states = False
cal_states_rotations = self.cal_states_rotations
for key in cal_states_rotations.keys():
if key == 'g' or key == 'e' or key == 'f':
states = True
for qbn in self.qb_names:
self.cal_states_dict_for_rotation[qbn] = OrderedDict()
if states:
cal_states_rot_qb = cal_states_rotations
else:
cal_states_rot_qb = cal_states_rotations[qbn]
for i in range(len(cal_states_rot_qb)):
cal_state = \
[k for k, idx in cal_states_rot_qb.items()
if idx == i][0]
self.cal_states_dict_for_rotation[qbn][cal_state] = \
None if do_PCA and self.num_cal_points != 3 else \
self.cal_states_dict[cal_state]
def cal_states_analysis(self):
self.get_cal_data_points()
self.proc_data_dict['projected_data_dict'] = OrderedDict(
{qbn: '' for qbn in self.qb_names})
for qbn in self.qb_names:
cal_states_dict = self.cal_states_dict_for_rotation[qbn]
if len(cal_states_dict) not in [0, 2, 3]:
raise NotImplementedError('Calibration states rotation is '
'currently only implemented for 0, '
'2, or 3 cal states per qubit.')
data_mostly_g = self.get_param_value('data_mostly_g',
default_value=True)
if self.get_param_value('TwoD', default_value=False):
if self.rotation_type == 'global_PCA':
self.proc_data_dict['projected_data_dict'].update(
self.global_pca_TwoD(
qbn, self.proc_data_dict['meas_results_per_qb'],
self.channel_map, self.data_to_fit,
data_mostly_g=data_mostly_g))
elif len(cal_states_dict) == 3:
self.proc_data_dict['projected_data_dict'].update(
self.rotate_data_3_cal_states_TwoD(
qbn, self.proc_data_dict['meas_results_per_qb'],
self.channel_map,
self.cal_states_dict_for_rotation))
elif self.rotation_type == 'fixed_cal_points':
rotated_data_dict, zero_coord, one_coord = \
self.rotate_data_TwoD_same_fixed_cal_idxs(
qbn, self.proc_data_dict['meas_results_per_qb'],
self.channel_map, self.cal_states_dict_for_rotation,
self.data_to_fit)
self.proc_data_dict['projected_data_dict'].update(
rotated_data_dict)
self.proc_data_dict['rotation_coordinates'] = \
[zero_coord, one_coord]
else:
self.proc_data_dict['projected_data_dict'].update(
self.rotate_data_TwoD(
qbn, self.proc_data_dict['meas_results_per_qb'],
self.channel_map, self.cal_states_dict_for_rotation,
self.data_to_fit, data_mostly_g=data_mostly_g,
column_PCA=self.rotation_type == 'column_PCA'))
else:
if len(cal_states_dict) == 3:
self.proc_data_dict['projected_data_dict'].update(
self.rotate_data_3_cal_states(
qbn, self.proc_data_dict['meas_results_per_qb'],
self.channel_map,
self.cal_states_dict_for_rotation))
else:
self.proc_data_dict['projected_data_dict'].update(
self.rotate_data(
qbn, self.proc_data_dict['meas_results_per_qb'],
self.channel_map, self.cal_states_dict_for_rotation,
self.data_to_fit, data_mostly_g=data_mostly_g))
@staticmethod
def rotate_data_3_cal_states(qb_name, meas_results_per_qb, channel_map,
cal_states_dict):
# FOR 3 CAL STATES
rotated_data_dict = OrderedDict()
meas_res_dict = meas_results_per_qb[qb_name]
rotated_data_dict[qb_name] = OrderedDict()
cal_pts_idxs = list(cal_states_dict[qb_name].values())
cal_points_data = np.zeros((len(cal_pts_idxs), 2))
if list(meas_res_dict) == channel_map[qb_name]:
raw_data = np.array([v for v in meas_res_dict.values()]).T
for i, cal_idx in enumerate(cal_pts_idxs):
cal_points_data[i, :] = np.mean(raw_data[cal_idx, :],
axis=0)
rotated_data = predict_proba_avg_ro(raw_data, cal_points_data)
for i, state in enumerate(list(cal_states_dict[qb_name])):
rotated_data_dict[qb_name][f'p{state}'] = rotated_data[:, i]
else:
raise NotImplementedError('Calibration states rotation with 3 '
'cal states only implemented for '
'2 readout channels per qubit.')
return rotated_data_dict
@staticmethod
def rotate_data(qb_name, meas_results_per_qb, channel_map,
cal_states_dict, data_to_fit, data_mostly_g=True):
# ONLY WORKS FOR 2 CAL STATES
meas_res_dict = meas_results_per_qb[qb_name]
rotated_data_dict = OrderedDict()
if len(cal_states_dict[qb_name]) == 0:
cal_zero_points = None
cal_one_points = None
else:
cal_zero_points = list(cal_states_dict[qb_name].values())[0]
cal_one_points = list(cal_states_dict[qb_name].values())[1]
rotated_data_dict[qb_name] = OrderedDict()
if len(meas_res_dict) == 1:
# one RO channel per qubit
if cal_zero_points is None and cal_one_points is None:
data = meas_res_dict[list(meas_res_dict)[0]]
data = (data - np.min(data))/(np.max(data) - np.min(data))
data = a_tools.set_majority_sign(
data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][data_to_fit[qb_name]] = data
else:
rotated_data_dict[qb_name][data_to_fit[qb_name]] = \
a_tools.rotate_and_normalize_data_1ch(
data=meas_res_dict[list(meas_res_dict)[0]],
cal_zero_points=cal_zero_points,
cal_one_points=cal_one_points)
elif list(meas_res_dict) == channel_map[qb_name]:
# two RO channels per qubit
data, _, _ = a_tools.rotate_and_normalize_data_IQ(
data=np.array([v for v in meas_res_dict.values()]),
cal_zero_points=cal_zero_points,
cal_one_points=cal_one_points)
if cal_zero_points is None:
data = a_tools.set_majority_sign(
data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][data_to_fit[qb_name]] = data
else:
# multiple readouts per qubit per channel
if isinstance(channel_map[qb_name], str):
qb_ro_ch0 = channel_map[qb_name]
else:
qb_ro_ch0 = channel_map[qb_name][0]
ro_suffixes = [s[len(qb_ro_ch0)+1::] for s in
list(meas_res_dict) if qb_ro_ch0 in s]
for i, ro_suf in enumerate(ro_suffixes):
if len(ro_suffixes) == len(meas_res_dict):
# one RO ch per qubit
if cal_zero_points is None and cal_one_points is None:
data = meas_res_dict[list(meas_res_dict)[i]]
data = (data - np.min(data))/(np.max(data) - np.min(data))
data = a_tools.set_majority_sign(
data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][ro_suf] = data
else:
rotated_data_dict[qb_name][ro_suf] = \
a_tools.rotate_and_normalize_data_1ch(
data=meas_res_dict[list(meas_res_dict)[i]],
cal_zero_points=cal_zero_points,
cal_one_points=cal_one_points)
else:
# two RO ch per qubit
keys = [k for k in meas_res_dict if ro_suf in k]
correct_keys = [k for k in keys
if k[len(qb_ro_ch0)+1::] == ro_suf]
data_array = np.array([meas_res_dict[k]
for k in correct_keys])
data, _, _ = a_tools.rotate_and_normalize_data_IQ(
data=data_array,
cal_zero_points=cal_zero_points,
cal_one_points=cal_one_points)
if cal_zero_points is None:
data = a_tools.set_majority_sign(
data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][ro_suf] = data
return rotated_data_dict
@staticmethod
def rotate_data_3_cal_states_TwoD(qb_name, meas_results_per_qb,
channel_map, cal_states_dict):
# FOR 3 CAL STATES
meas_res_dict = meas_results_per_qb[qb_name]
rotated_data_dict = OrderedDict()
rotated_data_dict[qb_name] = OrderedDict()
cal_pts_idxs = list(cal_states_dict[qb_name].values())
cal_points_data = np.zeros((len(cal_pts_idxs), 2))
if list(meas_res_dict) == channel_map[qb_name]:
# two RO channels per qubit
raw_data_arr = meas_res_dict[list(meas_res_dict)[0]]
for i, state in enumerate(list(cal_states_dict[qb_name])):
rotated_data_dict[qb_name][f'p{state}'] = np.zeros(
raw_data_arr.shape)
for col in range(raw_data_arr.shape[1]):
raw_data = np.concatenate([
v[:, col].reshape(len(v[:, col]), 1) for
v in meas_res_dict.values()], axis=1)
for i, cal_idx in enumerate(cal_pts_idxs):
cal_points_data[i, :] = np.mean(raw_data[cal_idx, :],
axis=0)
# rotated data is (raw_data_arr.shape[0], 3)
rotated_data = predict_proba_avg_ro(
raw_data, cal_points_data)
for i, state in enumerate(list(cal_states_dict[qb_name])):
rotated_data_dict[qb_name][f'p{state}'][:, col] = \
rotated_data[:, i]
else:
raise NotImplementedError('Calibration states rotation with 3 '
'cal states only implemented for '
'2 readout channels per qubit.')
# transpose data
for i, state in enumerate(list(cal_states_dict[qb_name])):
rotated_data_dict[qb_name][f'p{state}'] = \
rotated_data_dict[qb_name][f'p{state}'].T
return rotated_data_dict
@staticmethod
def global_pca_TwoD(qb_name, meas_results_per_qb, channel_map,
data_to_fit, data_mostly_g=True):
meas_res_dict = meas_results_per_qb[qb_name]
if list(meas_res_dict) != channel_map[qb_name]:
raise NotImplementedError('Global PCA is only implemented '
'for two-channel RO!')
raw_data_arr = meas_res_dict[list(meas_res_dict)[0]]
rotated_data_dict = OrderedDict({qb_name: OrderedDict()})
rotated_data_dict[qb_name][data_to_fit[qb_name]] = \
deepcopy(raw_data_arr.transpose())
data_array = np.array(
[v.T.flatten() for v in meas_res_dict.values()])
rot_flat_data, _, _ = \
a_tools.rotate_and_normalize_data_IQ(
data=data_array)
data = np.reshape(rot_flat_data, raw_data_arr.T.shape)
data = a_tools.set_majority_sign(data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][data_to_fit[qb_name]] = data
return rotated_data_dict
@staticmethod
def rotate_data_TwoD(qb_name, meas_results_per_qb, channel_map,
cal_states_dict, data_to_fit,
column_PCA=False, data_mostly_g=True):
meas_res_dict = meas_results_per_qb[qb_name]
rotated_data_dict = OrderedDict()
if len(cal_states_dict[qb_name]) == 0:
cal_zero_points = None
cal_one_points = None
else:
cal_zero_points = list(cal_states_dict[qb_name].values())[0]
cal_one_points = list(cal_states_dict[qb_name].values())[1]
rotated_data_dict[qb_name] = OrderedDict()
if len(meas_res_dict) == 1:
# one RO channel per qubit
raw_data_arr = meas_res_dict[list(meas_res_dict)[0]]
rotated_data_dict[qb_name][data_to_fit[qb_name]] = \
deepcopy(raw_data_arr.transpose())
if column_PCA:
for row in range(raw_data_arr.shape[0]):
data = a_tools.rotate_and_normalize_data_1ch(
data=raw_data_arr[row, :],
cal_zero_points=cal_zero_points,
cal_one_points=cal_one_points)
data = a_tools.set_majority_sign(
data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][data_to_fit[qb_name]][
:, row] = data
else:
for col in range(raw_data_arr.shape[1]):
data = a_tools.rotate_and_normalize_data_1ch(
data=raw_data_arr[:, col],
cal_zero_points=cal_zero_points,
cal_one_points=cal_one_points)
if cal_zero_points is None:
data = a_tools.set_majority_sign(
data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][data_to_fit[qb_name]][col] = data
elif list(meas_res_dict) == channel_map[qb_name]:
# two RO channels per qubit
raw_data_arr = meas_res_dict[list(meas_res_dict)[0]]
rotated_data_dict[qb_name][data_to_fit[qb_name]] = \
deepcopy(raw_data_arr.transpose())
if column_PCA:
for row in range(raw_data_arr.shape[0]):
data_array = np.array(
[v[row, :] for v in meas_res_dict.values()])
data, _, _ = \
a_tools.rotate_and_normalize_data_IQ(
data=data_array,
cal_zero_points=cal_zero_points,
cal_one_points=cal_one_points)
data = a_tools.set_majority_sign(
data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][data_to_fit[qb_name]][
:, row] = data
else:
for col in range(raw_data_arr.shape[1]):
data_array = np.array(
[v[:, col] for v in meas_res_dict.values()])
data, _, _ = a_tools.rotate_and_normalize_data_IQ(
data=data_array,
cal_zero_points=cal_zero_points,
cal_one_points=cal_one_points)
if cal_zero_points is None:
data = a_tools.set_majority_sign(
data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][
data_to_fit[qb_name]][col] = data
else:
# multiple readouts per qubit per channel
if isinstance(channel_map[qb_name], str):
qb_ro_ch0 = channel_map[qb_name]
else:
qb_ro_ch0 = channel_map[qb_name][0]
ro_suffixes = [s[len(qb_ro_ch0)+1::] for s in
list(meas_res_dict) if qb_ro_ch0 in s]
for i, ro_suf in enumerate(ro_suffixes):
if len(ro_suffixes) == len(meas_res_dict):
# one RO ch per qubit
raw_data_arr = meas_res_dict[list(meas_res_dict)[i]]
rotated_data_dict[qb_name][ro_suf] = \
deepcopy(raw_data_arr.transpose())
for col in range(raw_data_arr.shape[1]):
data = a_tools.rotate_and_normalize_data_1ch(
data=raw_data_arr[:, col],
cal_zero_points=cal_zero_points,
cal_one_points=cal_one_points)
if cal_zero_points is None:
data = a_tools.set_majority_sign(
data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][ro_suf][col] = data
else:
# two RO ch per qubit
raw_data_arr = meas_res_dict[list(meas_res_dict)[i]]
rotated_data_dict[qb_name][ro_suf] = \
deepcopy(raw_data_arr.transpose())
for col in range(raw_data_arr.shape[1]):
data_array = np.array(
[v[:, col] for k, v in meas_res_dict.items()
if ro_suf in k])
data, _, _ = a_tools.rotate_and_normalize_data_IQ(
data=data_array,
cal_zero_points=cal_zero_points,
cal_one_points=cal_one_points)
if cal_zero_points is None:
data = a_tools.set_majority_sign(
data, -1 if data_mostly_g else 1)
rotated_data_dict[qb_name][ro_suf][col] = data
return rotated_data_dict
@staticmethod
def rotate_data_TwoD_same_fixed_cal_idxs(qb_name, meas_results_per_qb,
channel_map, cal_states_dict,
data_to_fit):
meas_res_dict = meas_results_per_qb[qb_name]
if list(meas_res_dict) != channel_map[qb_name]:
raise NotImplementedError('rotate_data_TwoD_same_fixed_cal_idxs '
'only implemented for two-channel RO!')
if len(cal_states_dict[qb_name]) == 0:
cal_zero_points = None
cal_one_points = None
else:
cal_zero_points = list(cal_states_dict[qb_name].values())[0]
cal_one_points = list(cal_states_dict[qb_name].values())[1]
# do pca on the one cal states
raw_data_arr = meas_res_dict[list(meas_res_dict)[0]]
rot_dat_e = np.zeros(raw_data_arr.shape[1])
for row in cal_one_points:
rot_dat_e += a_tools.rotate_and_normalize_data_IQ(
data=np.array([v[row, :] for v in meas_res_dict.values()]),
cal_zero_points=None, cal_one_points=None)[0]
rot_dat_e /= len(cal_one_points)
# find the values of the zero and one cal points
col_idx = np.argmax(np.abs(rot_dat_e))
zero_coord = [np.mean([v[r, col_idx] for r in cal_zero_points])
for v in meas_res_dict.values()]
one_coord = [np.mean([v[r, col_idx] for r in cal_one_points])
for v in meas_res_dict.values()]
# rotate all data based on the fixed zero_coord and one_coord
rotated_data_dict = OrderedDict({qb_name: OrderedDict()})
rotated_data_dict[qb_name][data_to_fit[qb_name]] = \
deepcopy(raw_data_arr.transpose())
for col in range(raw_data_arr.shape[1]):
data_array = np.array(
[v[:, col] for v in meas_res_dict.values()])
rotated_data_dict[qb_name][
data_to_fit[qb_name]][col], _, _ = \
a_tools.rotate_and_normalize_data_IQ(
data=data_array,
zero_coord=zero_coord,
one_coord=one_coord)
return rotated_data_dict, zero_coord, one_coord
def get_xaxis_label_unit(self, qb_name):
hard_sweep_params = self.get_param_value('hard_sweep_params')
sweep_name = self.get_param_value('sweep_name')
sweep_unit = self.get_param_value('sweep_unit')
if self.sp is not None:
main_sp = self.get_param_value('main_sp', None)
if main_sp is not None and qb_name in main_sp:
param_names = [main_sp[qb_name]]
else:
param_names = self.mospm[qb_name]
_, xunit, xlabel = self.sp.get_sweep_params_description(
param_names=param_names, dimension=0)[0]
elif hard_sweep_params is not None:
xlabel = list(hard_sweep_params)[0]
xunit = list(hard_sweep_params.values())[0][
'unit']
elif (sweep_name is not None) and (sweep_unit is not None):
xlabel = sweep_name
xunit = sweep_unit
else:
xlabel = self.raw_data_dict['sweep_parameter_names']
xunit = self.raw_data_dict['sweep_parameter_units']
if np.ndim(xlabel) > 0:
xlabel = xlabel[0]
if np.ndim(xunit) > 0:
xunit = xunit[0]
return xlabel, xunit
@staticmethod
def get_cal_state_color(cal_state_label):
if cal_state_label == 'g' or cal_state_label == r'$|g\rangle$':
return 'k'
elif cal_state_label == 'e' or cal_state_label == r'$|e\rangle$':
return 'gray'
elif cal_state_label == 'f' or cal_state_label == r'$|f\rangle$':
return 'C8'
else:
return 'C4'
@staticmethod
def get_latex_prob_label(prob_label):
if '$' in prob_label:
return prob_label
elif 'p' in prob_label.lower():
return r'$|{}\rangle$'.format(prob_label[-1])
else:
return r'$|{}\rangle$'.format(prob_label)
def prepare_plots(self):
if self.get_param_value('plot_proj_data', default_value=True):
select_split = self.get_param_value('select_split')
fig_name_suffix = self.get_param_value('fig_name_suffix', '')
title_suffix = self.get_param_value('title_suffix', '')
for qb_name, corr_data in self.proc_data_dict[
'projected_data_dict'].items():
fig_name = f'projected_plot_{qb_name}'
title_suf = title_suffix
if select_split is not None:
param, idx = select_split[qb_name]
# remove qb_name from param
p = '_'.join([e for e in param.split('_') if e != qb_name])
# create suffix
suf = f'({p}, {str(np.round(idx, 3))})'
# add suffix
fig_name += f'_{suf}'
title_suf = f'{suf}_{title_suf}' if \
len(title_suf) else suf
if isinstance(corr_data, dict):
for data_key, data in corr_data.items():
if not self.rotate:
data_label = data_key
plot_name_suffix = data_key
plot_cal_points = False
data_axis_label = 'Population'
else:
fn = f'{fig_name}_{data_key}'
data_label = 'Data'
plot_name_suffix = ''
tf = f'{data_key}_{title_suf}' if \
len(title_suf) else data_key
plot_cal_points = (
not self.options_dict.get('TwoD', False))
data_axis_label = \
'Strongest principal component (arb.)' if \
'pca' in self.rotation_type.lower() else \
'{} state population'.format(
self.get_latex_prob_label(data_key))
self.prepare_projected_data_plot(
fn, data, qb_name=qb_name,
data_label=data_label,
title_suffix=tf,
plot_name_suffix=plot_name_suffix,
fig_name_suffix=fig_name_suffix,
data_axis_label=data_axis_label,
plot_cal_points=plot_cal_points)
else:
fig_name = 'projected_plot_' + qb_name
self.prepare_projected_data_plot(
fig_name, corr_data, qb_name=qb_name,
plot_cal_points=(
not self.options_dict.get('TwoD', False)))
if self.get_param_value('plot_raw_data', default_value=True):
self.prepare_raw_data_plots(plot_filtered=False)
if 'preparation_params' in self.metadata:
if 'active' in self.metadata['preparation_params'].get(
'preparation_type', 'wait'):
self.prepare_raw_data_plots(plot_filtered=True)
def prepare_raw_data_plots(self, plot_filtered=False):
if plot_filtered or not self.data_with_reset:
key = 'meas_results_per_qb'
suffix = 'filtered' if self.data_with_reset else ''
func_for_swpts = lambda qb_name: self.proc_data_dict[
'sweep_points_dict'][qb_name]['sweep_points']
else:
key = 'meas_results_per_qb_raw'
suffix = ''
func_for_swpts = lambda qb_name: self.raw_data_dict[
'hard_sweep_points']
for qb_name, raw_data_dict in self.proc_data_dict[key].items():
if qb_name not in self.qb_names:
continue
sweep_points = func_for_swpts(qb_name)
if len(raw_data_dict) == 1:
numplotsx = 1
numplotsy = 1
elif len(raw_data_dict) == 2:
numplotsx = 1
numplotsy = 2
else:
numplotsx = 2
numplotsy = len(raw_data_dict) // 2 + len(raw_data_dict) % 2
plotsize = self.get_default_plot_params(set=False)['figure.figsize']
fig_title = (self.raw_data_dict['timestamp'] + ' ' +
self.raw_data_dict['measurementstring'] +
'\nRaw data ' + suffix + ' ' + qb_name)
plot_name = 'raw_plot_' + qb_name + suffix
xlabel, xunit = self.get_xaxis_label_unit(qb_name)
for ax_id, ro_channel in enumerate(raw_data_dict):
if self.get_param_value('TwoD', default_value=False):
if self.sp is None:
soft_sweep_params = self.get_param_value(
'soft_sweep_params')
if soft_sweep_params is not None:
yunit = list(soft_sweep_params.values())[0]['unit']
else:
yunit = self.raw_data_dict[
'sweep_parameter_units'][1]
if np.ndim(yunit) > 0:
yunit = yunit[0]
for pn, ssp in self.proc_data_dict['sweep_points_2D_dict'][
qb_name].items():
ylabel = pn
if self.sp is not None:
yunit = self.sp.get_sweep_params_property(
'unit', dimension=1, param_names=pn)
ylabel = self.sp.get_sweep_params_property(
'label', dimension=1, param_names=pn)
self.plot_dicts[f'{plot_name}_{ro_channel}_{pn}'] = {
'fig_id': plot_name + '_' + pn,
'ax_id': ax_id,
'plotfn': self.plot_colorxy,
'xvals': sweep_points,
'yvals': ssp,
'zvals': raw_data_dict[ro_channel].T,
'xlabel': xlabel,
'xunit': xunit,
'ylabel': ylabel,
'yunit': yunit,
'numplotsx': numplotsx,
'numplotsy': numplotsy,
'plotsize': (plotsize[0]*numplotsx,
plotsize[1]*numplotsy),
'title': fig_title,
'clabel': '{} (Vpeak)'.format(ro_channel)}
else:
self.plot_dicts[plot_name + '_' + ro_channel] = {
'fig_id': plot_name,
'ax_id': ax_id,
'plotfn': self.plot_line,
'xvals': sweep_points,
'xlabel': xlabel,
'xunit': xunit,
'yvals': raw_data_dict[ro_channel],
'ylabel': '{} (Vpeak)'.format(ro_channel),
'yunit': '',
'numplotsx': numplotsx,
'numplotsy': numplotsy,
'plotsize': (plotsize[0]*numplotsx,
plotsize[1]*numplotsy),
'title': fig_title}
if len(raw_data_dict) == 1:
self.plot_dicts[
plot_name + '_' + list(raw_data_dict)[0]]['ax_id'] = None
def prepare_projected_data_plot(
self, fig_name, data, qb_name, title_suffix='', sweep_points=None,
plot_cal_points=True, plot_name_suffix='', fig_name_suffix='',
data_label='Data', data_axis_label='', do_legend_data=True,
do_legend_cal_states=True):
if len(fig_name_suffix):
fig_name = f'{fig_name}_{fig_name_suffix}'
if data_axis_label == '':
data_axis_label = 'Strongest principal component (arb.)' if \
'pca' in self.rotation_type.lower() else \
'{} state population'.format(self.get_latex_prob_label(
self.data_to_fit[qb_name]))
plotsize = self.get_default_plot_params(set=False)['figure.figsize']
plotsize = (plotsize[0], plotsize[0]/1.25)
if sweep_points is None:
sweep_points = self.proc_data_dict['sweep_points_dict'][qb_name][
'sweep_points']
plot_names_cal = []
if plot_cal_points and self.num_cal_points != 0:
yvals = data[:-self.num_cal_points]
xvals = sweep_points[:-self.num_cal_points]
# plot cal points
for i, cal_pts_idxs in enumerate(
self.cal_states_dict.values()):
plot_dict_name_cal = fig_name + '_' + \
list(self.cal_states_dict)[i] + '_' + \
plot_name_suffix
plot_names_cal += [plot_dict_name_cal]
self.plot_dicts[plot_dict_name_cal] = {
'fig_id': fig_name,
'plotfn': self.plot_line,
'plotsize': plotsize,
'xvals': self.proc_data_dict['sweep_points_dict'][qb_name][
'cal_points_sweep_points'][cal_pts_idxs],
'yvals': data[cal_pts_idxs],
'setlabel': list(self.cal_states_dict)[i],
'do_legend': do_legend_cal_states,
'legend_bbox_to_anchor': (1, 0.5),
'legend_pos': 'center left',
'linestyle': 'none',
'line_kws': {'color': self.get_cal_state_color(
list(self.cal_states_dict)[i])}}
self.plot_dicts[plot_dict_name_cal+'_line'] = {
'fig_id': fig_name,
'plotsize': plotsize,
'plotfn': self.plot_hlines,
'y': np.mean(data[cal_pts_idxs]),
'xmin': self.proc_data_dict['sweep_points_dict'][qb_name][
'sweep_points'][0],
'xmax': self.proc_data_dict['sweep_points_dict'][qb_name][
'sweep_points'][-1],
'colors': 'gray'}
else:
yvals = data
xvals = sweep_points
title = (self.raw_data_dict['timestamp'] + ' ' +
self.raw_data_dict['measurementstring'])
title += '\n' + f'{qb_name}_{title_suffix}' if len(title_suffix) else \
' ' + qb_name
plot_dict_name = f'{fig_name}_{plot_name_suffix}'
xlabel, xunit = self.get_xaxis_label_unit(qb_name)
if self.get_param_value('TwoD', default_value=False):
if self.sp is None:
soft_sweep_params = self.get_param_value(
'soft_sweep_params')
if soft_sweep_params is not None:
yunit = list(soft_sweep_params.values())[0]['unit']
else:
yunit = self.raw_data_dict['sweep_parameter_units'][1]
if np.ndim(yunit) > 0:
yunit = yunit[0]
for pn, ssp in self.proc_data_dict['sweep_points_2D_dict'][
qb_name].items():
ylabel = pn
if self.sp is not None:
yunit = self.sp.get_sweep_params_property(
'unit', dimension=1, param_names=pn)
ylabel = self.sp.get_sweep_params_property(
'label', dimension=1, param_names=pn)
self.plot_dicts[f'{plot_dict_name}_{pn}'] = {
'plotfn': self.plot_colorxy,
'fig_id': fig_name + '_' + pn,
'xvals': xvals,
'yvals': ssp,
'zvals': yvals,
'xlabel': xlabel,
'xunit': xunit,
'ylabel': ylabel,
'yunit': yunit,
'zrange': self.get_param_value('zrange', None),
'title': title,
'clabel': data_axis_label}
else:
self.plot_dicts[plot_dict_name] = {
'plotfn': self.plot_line,
'fig_id': fig_name,
'plotsize': plotsize,
'xvals': xvals,
'xlabel': xlabel,
'xunit': xunit,
'yvals': yvals,
'ylabel': data_axis_label,
'yunit': '',
'setlabel': data_label,
'title': title,
'linestyle': 'none',
'do_legend': do_legend_data,
'legend_bbox_to_anchor': (1, 0.5),
'legend_pos': 'center left'}
# add plot_params to each plot dict
plot_params = self.get_param_value('plot_params', default_value={})
for plt_name in self.plot_dicts:
self.plot_dicts[plt_name].update(plot_params)
if len(plot_names_cal) > 0:
if do_legend_data and not do_legend_cal_states:
for plot_name in plot_names_cal:
plot_dict_cal = self.plot_dicts.pop(plot_name)
self.plot_dicts[plot_name] = plot_dict_cal
class Idling_Error_Rate_Analyisis(ba.BaseDataAnalysis):
def __init__(self, t_start: str=None, t_stop: str=None,
label: str='', data_file_path: str=None,
options_dict: dict=None, extract_only: bool=False,
do_fitting: bool=True, auto=True):
super().__init__(t_start=t_start, t_stop=t_stop,
label=label,
data_file_path=data_file_path,
options_dict=options_dict,
extract_only=extract_only, do_fitting=do_fitting)
self.params_dict = {'xlabel': 'sweep_name',
'xunit': 'sweep_unit',
'xvals': 'sweep_points',
'measurementstring': 'measurementstring',
'value_names': 'value_names',
'value_units': 'value_units',
'measured_values': 'measured_values'}
self.numeric_params = []
if auto:
self.run_analysis()
def process_data(self):
post_sel_th = self.options_dict.get('post_sel_th', 0.5)
raw_shots = self.raw_data_dict['measured_values'][0][0]
post_sel_shots = raw_shots[::2]
data_shots = raw_shots[1::2]
data_shots[np.where(post_sel_shots > post_sel_th)] = np.nan
states = ['0', '1', '+']
self.proc_data_dict['xvals'] = np.unique(self.raw_data_dict['xvals'])
for i, state in enumerate(states):
self.proc_data_dict['shots_{}'.format(state)] =data_shots[i::3]
self.proc_data_dict['yvals_{}'.format(state)] = \
np.nanmean(np.reshape(self.proc_data_dict['shots_{}'.format(state)],
(len(self.proc_data_dict['xvals']), -1),
order='F'), axis=1)
def prepare_plots(self):
# assumes that value names are unique in an experiment
states = ['0', '1', '+']
for i, state in enumerate(states):
yvals = self.proc_data_dict['yvals_{}'.format(state)]
xvals = self.proc_data_dict['xvals']
self.plot_dicts['Prepare in {}'.format(state)] = {
'ax_id': 'main',
'plotfn': self.plot_line,
'xvals': xvals,
'xlabel': self.raw_data_dict['xlabel'][0],
'xunit': self.raw_data_dict['xunit'][0][0],
'yvals': yvals,
'ylabel': 'Counts',
'yrange': [0, 1],
'xrange': self.options_dict.get('xrange', None),
'yunit': 'frac',
'setlabel': 'Prepare in {}'.format(state),
'do_legend':True,
'title': (self.raw_data_dict['timestamps'][0]+' - ' +
self.raw_data_dict['timestamps'][-1] + '\n' +
self.raw_data_dict['measurementstring'][0]),
'legend_pos': 'upper right'}
if self.do_fitting:
for state in ['0', '1', '+']:
self.plot_dicts['fit_{}'.format(state)] = {
'ax_id': 'main',
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['fit {}'.format(state)]['fit_res'],
'plot_init': self.options_dict['plot_init'],
'setlabel': 'fit |{}>'.format(state),
'do_legend': True,
'legend_pos': 'upper right'}
self.plot_dicts['fit_text']={
'ax_id':'main',
'box_props': 'fancy',
'xpos':1.05,
'horizontalalignment':'left',
'plotfn': self.plot_text,
'text_string': self.proc_data_dict['fit_msg']}
def analyze_fit_results(self):
fit_msg =''
states = ['0', '1', '+']
for state in states:
fr = self.fit_res['fit {}'.format(state)]
N1 = fr.params['N1'].value, fr.params['N1'].stderr
N2 = fr.params['N2'].value, fr.params['N2'].stderr
fit_msg += ('Prep |{}> : \n\tN_1 = {:.2g} $\pm$ {:.2g}'
'\n\tN_2 = {:.2g} $\pm$ {:.2g}\n').format(
state, N1[0], N1[1], N2[0], N2[1])
self.proc_data_dict['fit_msg'] = fit_msg
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
states = ['0', '1', '+']
for i, state in enumerate(states):
yvals = self.proc_data_dict['yvals_{}'.format(state)]
xvals = self.proc_data_dict['xvals']
mod = lmfit.Model(fit_mods.idle_error_rate_exp_decay)
mod.guess = fit_mods.idle_err_rate_guess.__get__(mod, mod.__class__)
# Done here explicitly so that I can overwrite a specific guess
guess_pars = mod.guess(N=xvals, data=yvals)
vary_N2 = self.options_dict.get('vary_N2', True)
if not vary_N2:
guess_pars['N2'].value = 1e21
guess_pars['N2'].vary = False
self.fit_dicts['fit {}'.format(states[i])] = {
'model': mod,
'fit_xvals': {'N': xvals},
'fit_yvals': {'data': yvals},
'guess_pars': guess_pars}
# Allows fixing the double exponential coefficient
class Grovers_TwoQubitAllStates_Analysis(ba.BaseDataAnalysis):
def __init__(self, t_start: str=None, t_stop: str=None,
label: str='', data_file_path: str=None,
options_dict: dict=None, extract_only: bool=False,
do_fitting: bool=True, auto=True):
super().__init__(t_start=t_start, t_stop=t_stop,
label=label,
data_file_path=data_file_path,
options_dict=options_dict,
extract_only=extract_only, do_fitting=do_fitting)
self.params_dict = {'xlabel': 'sweep_name',
'xunit': 'sweep_unit',
'xvals': 'sweep_points',
'measurementstring': 'measurementstring',
'value_names': 'value_names',
'value_units': 'value_units',
'measured_values': 'measured_values'}
self.numeric_params = []
if auto:
self.run_analysis()
def process_data(self):
self.proc_data_dict = OrderedDict()
normalize_to_cal_points = self.options_dict.get('normalize_to_cal_points', True)
cal_points = [
[[-4, -3], [-2, -1]],
[[-4, -2], [-3, -1]],
]
for idx in [0,1]:
yvals = list(self.raw_data_dict['measured_data'].values())[idx][0]
self.proc_data_dict['ylabel_{}'.format(idx)] = \
self.raw_data_dict['value_names'][0][idx]
self.proc_data_dict['yunit'] = self.raw_data_dict['value_units'][0][idx]
if normalize_to_cal_points:
yvals = a_tools.rotate_and_normalize_data_1ch(yvals,
cal_zero_points=cal_points[idx][0],
cal_one_points=cal_points[idx][1])
self.proc_data_dict['yvals_{}'.format(idx)] = yvals
y0 = self.proc_data_dict['yvals_0']
y1 = self.proc_data_dict['yvals_1']
p_success = ((y0[0]*y1[0]) +
(1-y0[1])*y1[1] +
(y0[2])*(1-y1[2]) +
(1-y0[3])*(1-y1[3]) )/4
self.proc_data_dict['p_success'] = p_success
def prepare_plots(self):
# assumes that value names are unique in an experiment
for i in [0, 1]:
yvals = self.proc_data_dict['yvals_{}'.format(i)]
xvals = self.raw_data_dict['xvals'][0]
ylabel = self.proc_data_dict['ylabel_{}'.format(i)]
self.plot_dicts['main_{}'.format(ylabel)] = {
'plotfn': self.plot_line,
'xvals': self.raw_data_dict['xvals'][0],
'xlabel': self.raw_data_dict['xlabel'][0],
'xunit': self.raw_data_dict['xunit'][0][0],
'yvals': self.proc_data_dict['yvals_{}'.format(i)],
'ylabel': ylabel,
'yunit': self.proc_data_dict['yunit'],
'title': (self.raw_data_dict['timestamps'][0] + ' \n' +
self.raw_data_dict['measurementstring'][0]),
'do_legend': False,
'legend_pos': 'upper right'}
self.plot_dicts['limit_text']={
'ax_id':'main_{}'.format(ylabel),
'box_props': 'fancy',
'xpos':1.05,
'horizontalalignment':'left',
'plotfn': self.plot_text,
'text_string': 'P succes = {:.3f}'.format(self.proc_data_dict['p_success'])}
class FlippingAnalysis(Single_Qubit_TimeDomainAnalysis):
def __init__(self, t_start: str=None, t_stop: str=None,
data_file_path: str=None,
options_dict: dict=None, extract_only: bool=False,
do_fitting: bool=True, auto=True):
super().__init__(t_start=t_start, t_stop=t_stop,
data_file_path=data_file_path,
options_dict=options_dict,
extract_only=extract_only, do_fitting=do_fitting)
self.single_timestamp = True
self.params_dict = {'xlabel': 'sweep_name',
'xunit': 'sweep_unit',
'measurementstring': 'measurementstring',
'sweep_points': 'sweep_points',
'value_names': 'value_names',
'value_units': 'value_units',
'measured_values': 'measured_values'}
# This analysis makes a hardcoded assumption on the calibration points
self.options_dict['cal_points'] = [list(range(-4, -2)),
list(range(-2, 0))]
self.numeric_params = []
if auto:
self.run_analysis()
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
# Even though we expect an exponentially damped oscillation we use
# a simple cosine as this gives more reliable fitting and we are only
# interested in extracting the frequency of the oscillation
cos_mod = lmfit.Model(fit_mods.CosFunc)
guess_pars = fit_mods.Cos_guess(
model=cos_mod, t=self.raw_data_dict['sweep_points'][:-4],
data=self.proc_data_dict['corr_data'][:-4])
# This enforces the oscillation to start at the equator
# and ensures that any over/under rotation is absorbed in the
# frequency
guess_pars['amplitude'].value = 0.5
guess_pars['amplitude'].vary = False
guess_pars['offset'].value = 0.5
guess_pars['offset'].vary = False
self.fit_dicts['cos_fit'] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': self.raw_data_dict['sweep_points'][:-4]},
'fit_yvals': {'data': self.proc_data_dict['corr_data'][:-4]},
'guess_pars': guess_pars}
# In the case there are very few periods we fall back on a small
# angle approximation to extract the drive detuning
poly_mod = lmfit.models.PolynomialModel(degree=1)
# the detuning can be estimated using on a small angle approximation
# c1 = d/dN (cos(2*pi*f N) ) evaluated at N = 0 -> c1 = -2*pi*f
poly_mod.set_param_hint('frequency', expr='-c1/(2*pi)')
guess_pars = poly_mod.guess(x=self.raw_data_dict['sweep_points'][:-4],
data=self.proc_data_dict['corr_data'][:-4])
# Constraining the line ensures that it will only give a good fit
# if the small angle approximation holds
guess_pars['c0'].vary = False
guess_pars['c0'].value = 0.5
self.fit_dicts['line_fit'] = {
'model': poly_mod,
'fit_xvals': {'x': self.raw_data_dict['sweep_points'][:-4]},
'fit_yvals': {'data': self.proc_data_dict['corr_data'][:-4]},
'guess_pars': guess_pars}
def analyze_fit_results(self):
sf_line = self._get_scale_factor_line()
sf_cos = self._get_scale_factor_cos()
self.proc_data_dict['scale_factor'] = self.get_scale_factor()
msg = 'Scale fact. based on '
if self.proc_data_dict['scale_factor'] == sf_cos:
msg += 'cos fit\n'
else:
msg += 'line fit\n'
msg += 'cos fit: {:.4f}\n'.format(sf_cos)
msg += 'line fit: {:.4f}'.format(sf_line)
self.raw_data_dict['scale_factor_msg'] = msg
# TODO: save scale factor to file
def get_scale_factor(self):
"""
Returns the scale factor that should correct for the error in the
pulse amplitude.
"""
# Model selection based on the Bayesian Information Criterion (BIC)
# as calculated by lmfit
if (self.fit_dicts['line_fit']['fit_res'].bic <
self.fit_dicts['cos_fit']['fit_res'].bic):
scale_factor = self._get_scale_factor_line()
else:
scale_factor = self._get_scale_factor_cos()
return scale_factor
def _get_scale_factor_cos(self):
# 1/period of the oscillation corresponds to the (fractional)
# over/under rotation error per gate
frequency = self.fit_dicts['cos_fit']['fit_res'].params['frequency']
# the square is needed to account for the difference between
# power and amplitude
scale_factor = (1+frequency)**2
phase = np.rad2deg(self.fit_dicts['cos_fit']['fit_res'].params['phase']) % 360
# phase ~90 indicates an under rotation so the scale factor
# has to be larger than 1. A phase ~270 indicates an over
# rotation so then the scale factor has to be smaller than one.
if phase > 180:
scale_factor = 1/scale_factor
return scale_factor
def _get_scale_factor_line(self):
# 1/period of the oscillation corresponds to the (fractional)
# over/under rotation error per gate
frequency = self.fit_dicts['line_fit']['fit_res'].params['frequency']
scale_factor = (1+frequency)**2
# no phase sign check is needed here as this is contained in the
# sign of the coefficient
return scale_factor
def prepare_plots(self):
self.plot_dicts['main'] = {
'plotfn': self.plot_line,
'xvals': self.raw_data_dict['sweep_points'],
'xlabel': self.raw_data_dict['xlabel'],
'xunit': self.raw_data_dict['xunit'], # does not do anything yet
'yvals': self.proc_data_dict['corr_data'],
'ylabel': 'Excited state population',
'yunit': '',
'setlabel': 'data',
'title': (self.raw_data_dict['timestamp'] + ' ' +
self.raw_data_dict['measurementstring']),
'do_legend': True,
'legend_pos': 'upper right'}
if self.do_fitting:
self.plot_dicts['line_fit'] = {
'ax_id': 'main',
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['line_fit']['fit_res'],
'plot_init': self.options_dict['plot_init'],
'setlabel': 'line fit',
'do_legend': True,
'legend_pos': 'upper right'}
self.plot_dicts['cos_fit'] = {
'ax_id': 'main',
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['cos_fit']['fit_res'],
'plot_init': self.options_dict['plot_init'],
'setlabel': 'cos fit',
'do_legend': True,
'legend_pos': 'upper right'}
self.plot_dicts['text_msg'] = {
'ax_id': 'main',
'ypos': 0.15,
'plotfn': self.plot_text,
'box_props': 'fancy',
'text_string': self.raw_data_dict['scale_factor_msg']}
class Intersect_Analysis(Single_Qubit_TimeDomainAnalysis):
"""
Analysis to extract the intercept of two parameters.
relevant options_dict parameters
ch_idx_A (int) specifies first channel for intercept
ch_idx_B (int) specifies second channel for intercept if same as first
it will assume data was taken interleaved.
"""
def __init__(self, t_start: str=None, t_stop: str=None,
data_file_path: str=None,
options_dict: dict=None, extract_only: bool=False,
do_fitting: bool=True, auto=True):
super().__init__(t_start=t_start, t_stop=t_stop,
data_file_path=data_file_path,
options_dict=options_dict,
extract_only=extract_only, do_fitting=do_fitting)
self.single_timestamp = False
self.params_dict = {'xlabel': 'sweep_name',
'xvals': 'sweep_points',
'xunit': 'sweep_unit',
'measurementstring': 'measurementstring',
'value_names': 'value_names',
'value_units': 'value_units',
'measured_values': 'measured_values'}
self.numeric_params = []
if auto:
self.run_analysis()
def process_data(self):
"""
selects the relevant acq channel based on "ch_idx_A" and "ch_idx_B"
specified in the options dict. If ch_idx_A and ch_idx_B are the same
it will unzip the data.
"""
self.proc_data_dict = deepcopy(self.raw_data_dict)
# The channel containing the data must be specified in the options dict
ch_idx_A = self.options_dict.get('ch_idx_A', 0)
ch_idx_B = self.options_dict.get('ch_idx_B', 0)
self.proc_data_dict['ylabel'] = self.raw_data_dict['value_names'][0][ch_idx_A]
self.proc_data_dict['yunit'] = self.raw_data_dict['value_units'][0][ch_idx_A]
if ch_idx_A == ch_idx_B:
yvals = list(self.raw_data_dict['measured_data'].values())[ch_idx_A][0]
self.proc_data_dict['xvals_A'] = self.raw_data_dict['xvals'][0][::2]
self.proc_data_dict['xvals_B'] = self.raw_data_dict['xvals'][0][1::2]
self.proc_data_dict['yvals_A'] = yvals[::2]
self.proc_data_dict['yvals_B'] = yvals[1::2]
else:
self.proc_data_dict['xvals_A'] = self.raw_data_dict['xvals'][0]
self.proc_data_dict['xvals_B'] = self.raw_data_dict['xvals'][0]
self.proc_data_dict['yvals_A'] = list(self.raw_data_dict
['measured_data'].values())[ch_idx_A][0]
self.proc_data_dict['yvals_B'] = list(self.raw_data_dict
['measured_data'].values())[ch_idx_B][0]
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
self.fit_dicts['line_fit_A'] = {
'model': lmfit.models.PolynomialModel(degree=2),
'fit_xvals': {'x': self.proc_data_dict['xvals_A']},
'fit_yvals': {'data': self.proc_data_dict['yvals_A']}}
self.fit_dicts['line_fit_B'] = {
'model': lmfit.models.PolynomialModel(degree=2),
'fit_xvals': {'x': self.proc_data_dict['xvals_B']},
'fit_yvals': {'data': self.proc_data_dict['yvals_B']}}
def analyze_fit_results(self):
fr_0 = self.fit_res['line_fit_A'].best_values
fr_1 = self.fit_res['line_fit_B'].best_values
c0 = (fr_0['c0'] - fr_1['c0'])
c1 = (fr_0['c1'] - fr_1['c1'])
c2 = (fr_0['c2'] - fr_1['c2'])
poly_coeff = [c0, c1, c2]
poly = np.polynomial.polynomial.Polynomial([fr_0['c0'],
fr_0['c1'], fr_0['c2']])
ic = np.polynomial.polynomial.polyroots(poly_coeff)
self.proc_data_dict['intersect_L'] = ic[0], poly(ic[0])
self.proc_data_dict['intersect_R'] = ic[1], poly(ic[1])
if (((np.min(self.proc_data_dict['xvals']))< ic[0]) and
( ic[0] < (np.max(self.proc_data_dict['xvals'])))):
self.proc_data_dict['intersect'] =self.proc_data_dict['intersect_L']
else:
self.proc_data_dict['intersect'] =self.proc_data_dict['intersect_R']
def prepare_plots(self):
self.plot_dicts['main'] = {
'plotfn': self.plot_line,
'xvals': self.proc_data_dict['xvals_A'],
'xlabel': self.proc_data_dict['xlabel'][0],
'xunit': self.proc_data_dict['xunit'][0][0],
'yvals': self.proc_data_dict['yvals_A'],
'ylabel': self.proc_data_dict['ylabel'],
'yunit': self.proc_data_dict['yunit'],
'setlabel': 'A',
'title': (self.proc_data_dict['timestamps'][0] + ' \n' +
self.proc_data_dict['measurementstring'][0]),
'do_legend': True,
'yrange': (0,1),
'legend_pos': 'upper right'}
self.plot_dicts['on'] = {
'plotfn': self.plot_line,
'ax_id': 'main',
'xvals': self.proc_data_dict['xvals_B'],
'xlabel': self.proc_data_dict['xlabel'][0],
'xunit': self.proc_data_dict['xunit'][0][0],
'yvals': self.proc_data_dict['yvals_B'],
'ylabel': self.proc_data_dict['ylabel'],
'yunit': self.proc_data_dict['yunit'],
'setlabel': 'B',
'do_legend': True,
'legend_pos': 'upper right'}
if self.do_fitting:
self.plot_dicts['line_fit_A'] = {
'ax_id': 'main',
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['line_fit_A']['fit_res'],
'plot_init': self.options_dict['plot_init'],
'setlabel': 'Fit A',
'do_legend': True}
self.plot_dicts['line_fit_B'] = {
'ax_id': 'main',
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['line_fit_B']['fit_res'],
'plot_init': self.options_dict['plot_init'],
'setlabel': 'Fit B',
'do_legend': True}
ic, ic_unit = SI_val_to_msg_str(
self.proc_data_dict['intersect'][0],
self.proc_data_dict['xunit'][0][0], return_type=float)
self.plot_dicts['intercept_message'] = {
'ax_id': 'main',
'plotfn': self.plot_line,
'xvals': [self.proc_data_dict['intersect'][0]],
'yvals': [self.proc_data_dict['intersect'][1]],
'line_kws': {'alpha': .5, 'color':'gray',
'markersize':15},
'marker': 'o',
'setlabel': 'Intercept: {:.1f} {}'.format(ic, ic_unit),
'do_legend': True}
def get_intersect(self):
return self.proc_data_dict['intersect']
class CZ_1QPhaseCal_Analysis(ba.BaseDataAnalysis):
"""
Analysis to extract the intercept for a single qubit phase calibration
experiment
N.B. this is a less generic version of "Intersect_Analysis" and should
be deprecated (MAR Dec 2017)
"""
def __init__(self, t_start: str=None, t_stop: str=None,
data_file_path: str=None,
options_dict: dict=None, extract_only: bool=False,
do_fitting: bool=True, auto=True):
super().__init__(t_start=t_start, t_stop=t_stop,
data_file_path=data_file_path,
options_dict=options_dict,
extract_only=extract_only, do_fitting=do_fitting)
self.single_timestamp = False
self.params_dict = {'xlabel': 'sweep_name',
'xunit': 'sweep_unit',
'xvals': 'sweep_points',
'measurementstring': 'measurementstring',
'value_names': 'value_names',
'value_units': 'value_units',
'measured_values': 'measured_values'}
self.numeric_params = []
if auto:
self.run_analysis()
def process_data(self):
"""
selects the relevant acq channel based on "ch_idx" in options dict and
then splits the data for th
"""
self.proc_data_dict = OrderedDict()
# The channel containing the data must be specified in the options dict
ch_idx = self.options_dict['ch_idx']
yvals = list(self.raw_data_dict['measured_data'].values())[ch_idx][0]
self.proc_data_dict['ylabel'] = self.raw_data_dict['value_names'][0][ch_idx]
self.proc_data_dict['yunit'] = self.raw_data_dict['value_units'][0][ch_idx]
self.proc_data_dict['xvals_off'] = self.raw_data_dict['xvals'][0][::2]
self.proc_data_dict['xvals_on'] = self.raw_data_dict['xvals'][0][1::2]
self.proc_data_dict['yvals_off'] = yvals[::2]
self.proc_data_dict['yvals_on'] = yvals[1::2]
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
self.fit_dicts['line_fit_off'] = {
'model': lmfit.models.PolynomialModel(degree=1),
'fit_xvals': {'x': self.proc_data_dict['xvals_off']},
'fit_yvals': {'data': self.proc_data_dict['yvals_off']}}
self.fit_dicts['line_fit_on'] = {
'model': lmfit.models.PolynomialModel(degree=1),
'fit_xvals': {'x': self.proc_data_dict['xvals_on']},
'fit_yvals': {'data': self.proc_data_dict['yvals_on']}}
def analyze_fit_results(self):
fr_0 = self.fit_res['line_fit_off'].best_values
fr_1 = self.fit_res['line_fit_on'].best_values
ic = -(fr_0['c0'] - fr_1['c0'])/(fr_0['c1'] - fr_1['c1'])
self.proc_data_dict['zero_phase_diff_intersect'] = ic
def prepare_plots(self):
self.plot_dicts['main'] = {
'plotfn': self.plot_line,
'xvals': self.proc_data_dict['xvals_off'],
'xlabel': self.raw_data_dict['xlabel'][0],
'xunit': self.raw_data_dict['xunit'][0][0],
'yvals': self.proc_data_dict['yvals_off'],
'ylabel': self.proc_data_dict['ylabel'],
'yunit': self.proc_data_dict['yunit'],
'setlabel': 'CZ off',
'title': (self.raw_data_dict['timestamps'][0] + ' \n' +
self.raw_data_dict['measurementstring'][0]),
'do_legend': True,
'yrange': (0,1),
'legend_pos': 'upper right'}
self.plot_dicts['on'] = {
'plotfn': self.plot_line,
'ax_id': 'main',
'xvals': self.proc_data_dict['xvals_on'],
'xlabel': self.raw_data_dict['xlabel'][0],
'xunit': self.raw_data_dict['xunit'][0][0],
'yvals': self.proc_data_dict['yvals_on'],
'ylabel': self.proc_data_dict['ylabel'],
'yunit': self.proc_data_dict['yunit'],
'setlabel': 'CZ on',
'do_legend': True,
'legend_pos': 'upper right'}
if self.do_fitting:
self.plot_dicts['line_fit_off'] = {
'ax_id': 'main',
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['line_fit_off']['fit_res'],
'plot_init': self.options_dict['plot_init'],
'setlabel': 'Fit CZ off',
'do_legend': True}
self.plot_dicts['line_fit_on'] = {
'ax_id': 'main',
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['line_fit_on']['fit_res'],
'plot_init': self.options_dict['plot_init'],
'setlabel': 'Fit CZ on',
'do_legend': True}
ic, ic_unit = SI_val_to_msg_str(
self.proc_data_dict['zero_phase_diff_intersect'],
self.raw_data_dict['xunit'][0][0], return_type=float)
self.plot_dicts['intercept_message'] = {
'ax_id': 'main',
'plotfn': self.plot_line,
'xvals': [self.proc_data_dict['zero_phase_diff_intersect']],
'yvals': [np.mean(self.proc_data_dict['xvals_on'])],
'line_kws': {'alpha': 0},
'setlabel': 'Intercept: {:.1f} {}'.format(ic, ic_unit),
'do_legend': True}
def get_zero_phase_diff_intersect(self):
return self.proc_data_dict['zero_phase_diff_intersect']
class Oscillation_Analysis(ba.BaseDataAnalysis):
"""
Very basic analysis to determine the phase of a single oscillation
that has an assumed period of 360 degrees.
"""
def __init__(self, t_start: str=None, t_stop: str=None,
data_file_path: str=None,
label: str='',
options_dict: dict=None, extract_only: bool=False,
do_fitting: bool=True, auto=True):
super().__init__(t_start=t_start, t_stop=t_stop,
label=label,
data_file_path=data_file_path,
options_dict=options_dict,
extract_only=extract_only, do_fitting=do_fitting)
self.single_timestamp = False
self.params_dict = {'xlabel': 'sweep_name',
'xunit': 'sweep_unit',
'xvals': 'sweep_points',
'measurementstring': 'measurementstring',
'value_names': 'value_names',
'value_units': 'value_units',
'measured_values': 'measured_values'}
self.numeric_params = []
if auto:
self.run_analysis()
def process_data(self):
self.proc_data_dict = OrderedDict()
idx = 1
self.proc_data_dict['yvals'] = list(self.raw_data_dict['measured_data'].values())[idx][0]
self.proc_data_dict['ylabel'] = self.raw_data_dict['value_names'][0][idx]
self.proc_data_dict['yunit'] = self.raw_data_dict['value_units'][0][idx]
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
cos_mod = fit_mods.CosModel
guess_pars = fit_mods.Cos_guess(
model=cos_mod, t=self.raw_data_dict['xvals'][0],
data=self.proc_data_dict['yvals'], freq_guess=1/360)
guess_pars['frequency'].value = 1/360
guess_pars['frequency'].vary = False
self.fit_dicts['cos_fit'] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': self.raw_data_dict['xvals'][0]},
'fit_yvals': {'data': self.proc_data_dict['yvals']},
'guess_pars': guess_pars}
def analyze_fit_results(self):
fr = self.fit_res['cos_fit'].best_values
self.proc_data_dict['phi'] = np.rad2deg(fr['phase'])
def prepare_plots(self):
self.plot_dicts['main'] = {
'plotfn': self.plot_line,
'xvals': self.raw_data_dict['xvals'][0],
'xlabel': self.raw_data_dict['xlabel'][0],
'xunit': self.raw_data_dict['xunit'][0][0],
'yvals': self.proc_data_dict['yvals'],
'ylabel': self.proc_data_dict['ylabel'],
'yunit': self.proc_data_dict['yunit'],
'title': (self.raw_data_dict['timestamps'][0] + ' \n' +
self.raw_data_dict['measurementstring'][0]),
'do_legend': True,
# 'yrange': (0,1),
'legend_pos': 'upper right'}
if self.do_fitting:
self.plot_dicts['cos_fit'] = {
'ax_id': 'main',
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['cos_fit']['fit_res'],
'plot_init': self.options_dict['plot_init'],
'setlabel': 'Fit',
'do_legend': True}
class Conditional_Oscillation_Analysis(ba.BaseDataAnalysis):
"""
Analysis to extract quantities from a conditional oscillation.
"""
def __init__(self, t_start: str=None, t_stop: str=None,
data_file_path: str=None,
label: str='',
options_dict: dict=None, extract_only: bool=False,
do_fitting: bool=True, auto=True):
super().__init__(t_start=t_start, t_stop=t_stop,
label=label,
data_file_path=data_file_path,
options_dict=options_dict,
extract_only=extract_only, do_fitting=do_fitting)
self.single_timestamp = False
self.params_dict = {'xlabel': 'sweep_name',
'xunit': 'sweep_unit',
'xvals': 'sweep_points',
'measurementstring': 'measurementstring',
'value_names': 'value_names',
'value_units': 'value_units',
'measured_values': 'measured_values'}
self.numeric_params = []
if auto:
self.run_analysis()
def process_data(self):
"""
selects the relevant acq channel based on "ch_idx_osc" and
"ch_idx_spec" in the options dict and then splits the data for the
off and on cases
"""
self.proc_data_dict = OrderedDict()
# The channel containing the data must be specified in the options dict
ch_idx_spec = self.options_dict.get('ch_idx_spec', 0)
ch_idx_osc = self.options_dict.get('ch_idx_osc', 1)
normalize_to_cal_points = self.options_dict.get('normalize_to_cal_points', True)
cal_points = [
[[-4, -3], [-2, -1]],
[[-4, -2], [-3, -1]],
]
i = 0
for idx, type_str in zip([ch_idx_osc, ch_idx_spec], ['osc', 'spec']):
yvals = list(self.raw_data_dict['measured_data'].values())[idx][0]
self.proc_data_dict['ylabel_{}'.format(type_str)] = self.raw_data_dict['value_names'][0][idx]
self.proc_data_dict['yunit'] = self.raw_data_dict['value_units'][0][idx]
if normalize_to_cal_points:
yvals = a_tools.rotate_and_normalize_data_1ch(yvals,
cal_zero_points=cal_points[i][0],
cal_one_points=cal_points[i][1])
i +=1
self.proc_data_dict['yvals_{}_off'.format(type_str)] = yvals[::2]
self.proc_data_dict['yvals_{}_on'.format(type_str)] = yvals[1::2]
self.proc_data_dict['xvals_off'] = self.raw_data_dict['xvals'][0][::2]
self.proc_data_dict['xvals_on'] = self.raw_data_dict['xvals'][0][1::2]
else:
self.proc_data_dict['yvals_{}_off'.format(type_str)] = yvals[::2]
self.proc_data_dict['yvals_{}_on'.format(type_str)] = yvals[1::2]
self.proc_data_dict['xvals_off'] = self.raw_data_dict['xvals'][0][::2]
self.proc_data_dict['xvals_on'] = self.raw_data_dict['xvals'][0][1::2]
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
cos_mod = fit_mods.CosModel
guess_pars = fit_mods.Cos_guess(
model=cos_mod, t=self.proc_data_dict['xvals_off'][:-2],
data=self.proc_data_dict['yvals_osc_off'][:-2],
freq_guess=1/360)
guess_pars['frequency'].value = 1/360
guess_pars['frequency'].vary = False
self.fit_dicts['cos_fit_off'] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': self.proc_data_dict['xvals_off'][:-2]},
'fit_yvals': {'data': self.proc_data_dict['yvals_osc_off'][:-2]},
'guess_pars': guess_pars}
cos_mod = fit_mods.CosModel
guess_pars = fit_mods.Cos_guess(
model=cos_mod, t=self.proc_data_dict['xvals_on'][:-2],
data=self.proc_data_dict['yvals_osc_on'][:-2],
freq_guess=1/360)
guess_pars['frequency'].value = 1/360
guess_pars['frequency'].vary = False
self.fit_dicts['cos_fit_on'] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': self.proc_data_dict['xvals_on'][:-2]},
'fit_yvals': {'data': self.proc_data_dict['yvals_osc_on'][:-2]},
'guess_pars': guess_pars}
def analyze_fit_results(self):
fr_0 = self.fit_res['cos_fit_off'].params
fr_1 = self.fit_res['cos_fit_on'].params
phi0 = np.rad2deg(fr_0['phase'].value)
phi1 = np.rad2deg(fr_1['phase'].value)
phi0_stderr = np.rad2deg(fr_0['phase'].stderr)
phi1_stderr = np.rad2deg(fr_1['phase'].stderr)
self.proc_data_dict['phi_0'] = phi0, phi0_stderr
self.proc_data_dict['phi_1'] = phi1, phi1_stderr
phi_cond_stderr = (phi0_stderr**2+phi1_stderr**2)**.5
self.proc_data_dict['phi_cond'] = (phi1 -phi0), phi_cond_stderr
osc_amp = np.mean([fr_0['amplitude'], fr_1['amplitude']])
osc_amp_stderr = np.sqrt(fr_0['amplitude'].stderr**2 +
fr_1['amplitude']**2)/2
self.proc_data_dict['osc_amp_0'] = (fr_0['amplitude'].value,
fr_0['amplitude'].stderr)
self.proc_data_dict['osc_amp_1'] = (fr_1['amplitude'].value,
fr_1['amplitude'].stderr)
self.proc_data_dict['osc_offs_0'] = (fr_0['offset'].value,
fr_0['offset'].stderr)
self.proc_data_dict['osc_offs_1'] = (fr_1['offset'].value,
fr_1['offset'].stderr)
offs_stderr = (fr_0['offset'].stderr**2+fr_1['offset'].stderr**2)**.5
self.proc_data_dict['offs_diff'] = (
fr_1['offset'].value - fr_0['offset'].value, offs_stderr)
# self.proc_data_dict['osc_amp'] = (osc_amp, osc_amp_stderr)
self.proc_data_dict['missing_fraction'] = (
np.mean(self.proc_data_dict['yvals_spec_on'][:-2]) -
np.mean(self.proc_data_dict['yvals_spec_off'][:-2]))
def prepare_plots(self):
self._prepare_main_oscillation_figure()
self._prepare_spectator_qubit_figure()
def _prepare_main_oscillation_figure(self):
self.plot_dicts['main'] = {
'plotfn': self.plot_line,
'xvals': self.proc_data_dict['xvals_off'],
'xlabel': self.raw_data_dict['xlabel'][0],
'xunit': self.raw_data_dict['xunit'][0][0],
'yvals': self.proc_data_dict['yvals_osc_off'],
'ylabel': self.proc_data_dict['ylabel_osc'],
'yunit': self.proc_data_dict['yunit'],
'setlabel': 'CZ off',
'title': (self.raw_data_dict['timestamps'][0] + ' \n' +
self.raw_data_dict['measurementstring'][0]),
'do_legend': True,
# 'yrange': (0,1),
'legend_pos': 'upper right'}
self.plot_dicts['on'] = {
'plotfn': self.plot_line,
'ax_id': 'main',
'xvals': self.proc_data_dict['xvals_on'],
'xlabel': self.raw_data_dict['xlabel'][0],
'xunit': self.raw_data_dict['xunit'][0][0],
'yvals': self.proc_data_dict['yvals_osc_on'],
'ylabel': self.proc_data_dict['ylabel_osc'],
'yunit': self.proc_data_dict['yunit'],
'setlabel': 'CZ on',
'do_legend': True,
'legend_pos': 'upper right'}
if self.do_fitting:
self.plot_dicts['cos_fit_off'] = {
'ax_id': 'main',
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['cos_fit_off']['fit_res'],
'plot_init': self.options_dict['plot_init'],
'setlabel': 'Fit CZ off',
'do_legend': True}
self.plot_dicts['cos_fit_on'] = {
'ax_id': 'main',
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['cos_fit_on']['fit_res'],
'plot_init': self.options_dict['plot_init'],
'setlabel': 'Fit CZ on',
'do_legend': True}
# offset as a guide for the eye
y = self.fit_res['cos_fit_off'].params['offset'].value
self.plot_dicts['cos_off_offset'] ={
'plotfn': self.plot_matplot_ax_method,
'ax_id':'main',
'func': 'axhline',
'plot_kws': {
'y': y, 'color': 'C0', 'linestyle': 'dotted'}
}
phase_message = (
'Phase diff.: {:.1f} $\pm$ {:.1f} deg\n'
'Phase off: {:.1f} $\pm$ {:.1f}deg\n'
'Phase on: {:.1f} $\pm$ {:.1f}deg\n'
'Osc. amp. off: {:.4f} $\pm$ {:.4f}\n'
'Osc. amp. on: {:.4f} $\pm$ {:.4f}\n'
'Offs. diff.: {:.4f} $\pm$ {:.4f}\n'
'Osc. offs. off: {:.4f} $\pm$ {:.4f}\n'
'Osc. offs. on: {:.4f} $\pm$ {:.4f}'.format(
self.proc_data_dict['phi_cond'][0],
self.proc_data_dict['phi_cond'][1],
self.proc_data_dict['phi_0'][0],
self.proc_data_dict['phi_0'][1],
self.proc_data_dict['phi_1'][0],
self.proc_data_dict['phi_1'][1],
self.proc_data_dict['osc_amp_0'][0],
self.proc_data_dict['osc_amp_0'][1],
self.proc_data_dict['osc_amp_1'][0],
self.proc_data_dict['osc_amp_1'][1],
self.proc_data_dict['offs_diff'][0],
self.proc_data_dict['offs_diff'][1],
self.proc_data_dict['osc_offs_0'][0],
self.proc_data_dict['osc_offs_0'][1],
self.proc_data_dict['osc_offs_1'][0],
self.proc_data_dict['osc_offs_1'][1]))
self.plot_dicts['phase_message'] = {
'ax_id': 'main',
'ypos': 0.9,
'xpos': 1.45,
'plotfn': self.plot_text,
'box_props': 'fancy',
'line_kws': {'alpha': 0},
'text_string': phase_message}
def _prepare_spectator_qubit_figure(self):
self.plot_dicts['spectator_qubit'] = {
'plotfn': self.plot_line,
'xvals': self.proc_data_dict['xvals_off'],
'xlabel': self.raw_data_dict['xlabel'][0],
'xunit': self.raw_data_dict['xunit'][0][0],
'yvals': self.proc_data_dict['yvals_spec_off'],
'ylabel': self.proc_data_dict['ylabel_spec'],
'yunit': self.proc_data_dict['yunit'],
'setlabel': 'CZ off',
'title': (self.raw_data_dict['timestamps'][0] + ' \n' +
self.raw_data_dict['measurementstring'][0]),
'do_legend': True,
# 'yrange': (0,1),
'legend_pos': 'upper right'}
self.plot_dicts['spec_on'] = {
'plotfn': self.plot_line,
'ax_id': 'spectator_qubit',
'xvals': self.proc_data_dict['xvals_on'],
'xlabel': self.raw_data_dict['xlabel'][0],
'xunit': self.raw_data_dict['xunit'][0][0],
'yvals': self.proc_data_dict['yvals_spec_on'],
'ylabel': self.proc_data_dict['ylabel_spec'],
'yunit': self.proc_data_dict['yunit'],
'setlabel': 'CZ on',
'do_legend': True,
'legend_pos': 'upper right'}
if self.do_fitting:
leak_msg = (
'Missing fraction: {:.2f} % '.format(
self.proc_data_dict['missing_fraction']*100))
self.plot_dicts['leak_msg'] = {
'ax_id': 'spectator_qubit',
'ypos': 0.7,
'plotfn': self.plot_text,
'box_props': 'fancy',
'line_kws': {'alpha': 0},
'text_string': leak_msg}
# offset as a guide for the eye
y = self.fit_res['cos_fit_on'].params['offset'].value
self.plot_dicts['cos_on_offset'] ={
'plotfn': self.plot_matplot_ax_method,
'ax_id':'main',
'func': 'axhline',
'plot_kws': {
'y': y, 'color': 'C1', 'linestyle': 'dotted'}
}
class StateTomographyAnalysis(ba.BaseDataAnalysis):
"""
Analyses the results of the state tomography experiment and calculates
the corresponding quantum state.
Possible options that can be passed in the options_dict parameter:
cal_points: A data structure specifying the indices of the calibration
points. See the AveragedTimedomainAnalysis for format.
The calibration points need to be in the same order as the
used basis for the result.
data_type: 'averaged' or 'singleshot'. For singleshot data each
measurement outcome is saved and arbitrary order correlations
between the states can be calculated.
meas_operators: (optional) A list of qutip operators or numpy 2d arrays.
This overrides the measurement operators otherwise
found from the calibration points.
covar_matrix: (optional) The covariance matrix of the measurement
operators as a 2d numpy array. Overrides the one found
from the calibration points.
use_covariance_matrix (bool): Flag to define whether to use the
covariance matrix
basis_rots_str: A list of standard PycQED pulse names that were
applied to qubits before measurement
basis_rots: As an alternative to single_qubit_pulses, the basis
rotations applied to the system as qutip operators or numpy
matrices can be given.
mle: True/False, whether to do maximum likelihood fit. If False, only
least squares fit will be done, which could give negative
eigenvalues for the density matrix.
imle: True/False, whether to do iterative maximum likelihood fit. If
True, it takes preference over maximum likelihood method. Otherwise
least squares fit will be done, then 'mle' option will be checked.
pauli_raw: True/False, extracts Pauli expected values from a measurement
without assignment correction based on calibration data. If True,
takes preference over other methods except pauli_corr.
pauli_values: True/False, extracts Pauli expected values from a
measurement with assignment correction based on calibration data.
If True, takes preference over other methods.
iterations (optional): maximum number of iterations allowed in imle.
Tomographies with more qubits require more iterations to converge.
tolerance (optional): minimum change across iterations allowed in imle.
The iteration will stop if it goes under this value. Tomographies
with more qubits require smaller tolerance to converge.
rho_target (optional): A qutip density matrix that the result will be
compared to when calculating fidelity.
"""
def __init__(self, *args, **kwargs):
auto = kwargs.pop('auto', True)
super().__init__(*args, **kwargs)
kwargs['auto'] = auto
self.single_timestamp = True
self.params_dict = {'exp_metadata': 'exp_metadata'}
self.numeric_params = []
self.data_type = self.options_dict['data_type']
if self.data_type == 'averaged':
self.base_analysis = AveragedTimedomainAnalysis(*args, **kwargs)
elif self.data_type == 'singleshot':
self.base_analysis = roa.MultiQubit_SingleShot_Analysis(
*args, **kwargs)
else:
raise KeyError("Invalid tomography data mode: '" + self.data_type +
"'. Valid modes are 'averaged' and 'singleshot'.")
if kwargs.get('auto', True):
self.run_analysis()
def process_data(self):
tomography_qubits = self.options_dict.get('tomography_qubits', None)
data, Fs, Omega = self.base_analysis.measurement_operators_and_results(
tomography_qubits)
if 'data_filter' in self.options_dict:
data = self.options_dict['data_filter'](data.T).T
data = data.T
for i, v in enumerate(data):
data[i] = v / v.sum()
data = data.T
Fs = self.options_dict.get('meas_operators', Fs)
Fs = [qtp.Qobj(F) for F in Fs]
d = Fs[0].shape[0]
self.proc_data_dict['d'] = d
Omega = self.options_dict.get('covar_matrix', Omega)
if Omega is None:
Omega = np.diag(np.ones(len(Fs)))
elif len(Omega.shape) == 1:
Omega = np.diag(Omega)
metadata = self.raw_data_dict.get('exp_metadata',
self.options_dict.get(
'exp_metadata', {}))
if metadata is None:
metadata = {}
self.raw_data_dict['exp_metadata'] = metadata
basis_rots_str = metadata.get('basis_rots_str', None)
basis_rots_str = self.options_dict.get('basis_rots_str', basis_rots_str)
if basis_rots_str is not None:
nr_qubits = int(np.round(np.log2(d)))
pulse_list = list(itertools.product(basis_rots_str,
repeat=nr_qubits))
rotations = tomo.standard_qubit_pulses_to_rotations(pulse_list)
else:
rotations = metadata.get('basis_rots', None)
rotations = self.options_dict.get('basis_rots', rotations)
if rotations is None:
raise KeyError("Either 'basis_rots_str' or 'basis_rots' "
"parameter must be passed in the options "
"dictionary or in the experimental metadata.")
rotations = [qtp.Qobj(U) for U in rotations]
all_Fs = tomo.rotated_measurement_operators(rotations, Fs)
all_Fs = list(itertools.chain(*np.array(all_Fs, dtype=np.object).T))
all_mus = np.array(list(itertools.chain(*data.T)))
all_Omegas = sp.linalg.block_diag(*[Omega] * len(data[0]))
self.proc_data_dict['meas_operators'] = all_Fs
self.proc_data_dict['covar_matrix'] = all_Omegas
self.proc_data_dict['meas_results'] = all_mus
if self.options_dict.get('pauli_values', False):
rho_pauli = tomo.pauli_values_tomography(all_mus,Fs,basis_rots_str)
self.proc_data_dict['rho_raw'] = rho_pauli
self.proc_data_dict['rho'] = rho_pauli
elif self.options_dict.get('pauli_raw', False):
pauli_raw = self.generate_raw_pauli_set()
rho_raw = tomo.pauli_set_to_density_matrix(pauli_raw)
self.proc_data_dict['rho_raw'] = rho_raw
self.proc_data_dict['rho'] = rho_raw
elif self.options_dict.get('imle', False):
it = metadata.get('iterations', None)
it = self.options_dict.get('iterations', it)
tol = metadata.get('tolerance', None)
tol = self.options_dict.get('tolerance', tol)
rho_imle = tomo.imle_tomography(
all_mus, all_Fs, it, tol)
self.proc_data_dict['rho_imle'] = rho_imle
self.proc_data_dict['rho'] = rho_imle
else:
rho_ls = tomo.least_squares_tomography(
all_mus, all_Fs,
all_Omegas if self.get_param_value('use_covariance_matrix', False)
else None )
self.proc_data_dict['rho_ls'] = rho_ls
self.proc_data_dict['rho'] = rho_ls
if self.options_dict.get('mle', False):
rho_mle = tomo.mle_tomography(
all_mus, all_Fs,
all_Omegas if self.get_param_value('use_covariance_matrix', False) else None,
rho_guess=rho_ls)
self.proc_data_dict['rho_mle'] = rho_mle
self.proc_data_dict['rho'] = rho_mle
rho = self.proc_data_dict['rho']
self.proc_data_dict['purity'] = (rho * rho).tr().real
rho_target = metadata.get('rho_target', None)
rho_target = self.options_dict.get('rho_target', rho_target)
if rho_target is not None:
self.proc_data_dict['fidelity'] = tomo.fidelity(rho, rho_target)
if d == 4:
self.proc_data_dict['concurrence'] = tomo.concurrence(rho)
else:
self.proc_data_dict['concurrence'] = 0
def prepare_plots(self):
self.prepare_density_matrix_plot()
d = self.proc_data_dict['d']
if 2 ** (d.bit_length() - 1) == d:
# dimension is power of two, plot expectation values of pauli
# operators
self.prepare_pauli_basis_plot()
def prepare_density_matrix_plot(self):
self.tight_fig = self.options_dict.get('tight_fig', False)
rho_target = self.raw_data_dict['exp_metadata'].get('rho_target', None)
rho_target = self.options_dict.get('rho_target', rho_target)
d = self.proc_data_dict['d']
xtick_labels = self.options_dict.get('rho_ticklabels', None)
ytick_labels = self.options_dict.get('rho_ticklabels', None)
if 2 ** (d.bit_length() - 1) == d:
nr_qubits = d.bit_length() - 1
fmt_string = '{{:0{}b}}'.format(nr_qubits)
labels = [fmt_string.format(i) for i in range(2 ** nr_qubits)]
if xtick_labels is None:
xtick_labels = ['$|' + lbl + r'\rangle$' for lbl in labels]
if ytick_labels is None:
ytick_labels = [r'$\langle' + lbl + '|$' for lbl in labels]
color = (0.5 * np.angle(self.proc_data_dict['rho'].full()) / np.pi) % 1.
cmap = self.options_dict.get('rho_colormap', self.default_phase_cmap())
if self.options_dict.get('pauli_raw', False):
title = 'Density matrix reconstructed from the Pauli (raw) set\n'
elif self.options_dict.get('pauli_values', False):
title = 'Density matrix reconstructed from the Pauli set\n'
elif self.options_dict.get('mle', False):
title = 'Maximum likelihood fit of the density matrix\n'
elif self.options_dict.get('it_mle', False):
title = 'Iterative maximum likelihood fit of the density matrix\n'
else:
title = 'Least squares fit of the density matrix\n'
empty_artist = mpl.patches.Rectangle((0, 0), 0, 0, visible=False)
legend_entries = [(empty_artist,
r'Purity, $Tr(\rho^2) = {:.1f}\%$'.format(
100 * self.proc_data_dict['purity']))]
if rho_target is not None:
legend_entries += [
(empty_artist, r'Fidelity, $F = {:.1f}\%$'.format(
100 * self.proc_data_dict['fidelity']))]
if d == 4:
legend_entries += [
(empty_artist, r'Concurrence, $C = {:.2f}$'.format(
self.proc_data_dict['concurrence']))]
meas_string = self.base_analysis.\
raw_data_dict['measurementstring']
if isinstance(meas_string, list):
if len(meas_string) > 1:
meas_string = meas_string[0] + ' to ' + meas_string[-1]
else:
meas_string = meas_string[0]
self.plot_dicts['density_matrix'] = {
'plotfn': self.plot_bar3D,
'3d': True,
'3d_azim': -35,
'3d_elev': 35,
'xvals': np.arange(d),
'yvals': np.arange(d),
'zvals': np.abs(self.proc_data_dict['rho'].full()),
'zrange': (0, 1),
'color': color,
'colormap': cmap,
'bar_widthx': 0.5,
'bar_widthy': 0.5,
'xtick_loc': np.arange(d),
'xtick_labels': xtick_labels,
'ytick_loc': np.arange(d),
'ytick_labels': ytick_labels,
'ctick_loc': np.linspace(0, 1, 5),
'ctick_labels': ['$0$', r'$\frac{1}{2}\pi$', r'$\pi$',
r'$\frac{3}{2}\pi$', r'$2\pi$'],
'clabel': 'Phase (rad)',
'title': (title + self.raw_data_dict['timestamp'] + ' ' +
meas_string),
'do_legend': True,
'legend_entries': legend_entries,
'legend_kws': dict(loc='upper left', bbox_to_anchor=(0, 0.94))
}
if rho_target is not None:
rho_target = qtp.Qobj(rho_target)
if rho_target.type == 'ket':
rho_target = rho_target * rho_target.dag()
elif rho_target.type == 'bra':
rho_target = rho_target.dag() * rho_target
self.plot_dicts['density_matrix_target'] = {
'plotfn': self.plot_bar3D,
'3d': True,
'3d_azim': -35,
'3d_elev': 35,
'xvals': np.arange(d),
'yvals': np.arange(d),
'zvals': np.abs(rho_target.full()),
'zrange': (0, 1),
'color': (0.5 * np.angle(rho_target.full()) / np.pi) % 1.,
'colormap': cmap,
'bar_widthx': 0.5,
'bar_widthy': 0.5,
'xtick_loc': np.arange(d),
'xtick_labels': xtick_labels,
'ytick_loc': np.arange(d),
'ytick_labels': ytick_labels,
'ctick_loc': np.linspace(0, 1, 5),
'ctick_labels': ['$0$', r'$\frac{1}{2}\pi$', r'$\pi$',
r'$\frac{3}{2}\pi$', r'$2\pi$'],
'clabel': 'Phase (rad)',
'title': ('Target density matrix\n' +
self.raw_data_dict['timestamp'] + ' ' +
meas_string),
'bar_kws': dict(zorder=1),
}
def generate_raw_pauli_set(self):
nr_qubits = self.proc_data_dict['d'].bit_length() - 1
pauli_raw_values = []
for op in tomo.generate_pauli_set(nr_qubits)[1]:
nr_terms = 0
sum_terms = 0.
for meas_op, meas_res in zip(self.proc_data_dict['meas_operators'],
self.proc_data_dict['meas_results']):
trace = (meas_op*op).tr().real
clss = int(trace*2)
if clss < 0:
sum_terms -= meas_res
nr_terms += 1
elif clss > 0:
sum_terms += meas_res
nr_terms += 1
pauli_raw_values.append(2**nr_qubits*sum_terms/nr_terms)
return pauli_raw_values
def generate_corr_pauli_set(self,Fs,rotations):
nr_qubits = self.proc_data_dict['d'].bit_length() - 1
Fs_corr = []
assign_corr = []
for i,F in enumerate(Fs):
new_op = np.zeros(2**nr_qubits)
new_op[i] = 1
Fs_corr.append(qtp.Qobj(np.diag(new_op)))
assign_corr.append(np.diag(F.full()))
pauli_Fs = tomo.rotated_measurement_operators(rotations, Fs_corr)
pauli_Fs = list(itertools.chain(*np.array(pauli_Fs, dtype=np.object).T))
mus = self.proc_data_dict['meas_results']
pauli_mus = np.reshape(mus,[-1,2**nr_qubits])
for i,raw_mus in enumerate(pauli_mus):
pauli_mus[i] = np.matmul(np.linalg.inv(assign_corr),np.array(raw_mus))
pauli_mus = pauli_mus.flatten()
pauli_values = []
for op in tomo.generate_pauli_set(nr_qubits)[1]:
nr_terms = 0
sum_terms = 0.
for meas_op, meas_res in zip(pauli_Fs,pauli_mus):
trace = (meas_op*op).tr().real
clss = int(trace*2)
if clss < 0:
sum_terms -= meas_res
nr_terms += 1
elif clss > 0:
sum_terms += meas_res
nr_terms += 1
pauli_values.append(2**nr_qubits*sum_terms/nr_terms)
return pauli_values
def prepare_pauli_basis_plot(self):
yexp = tomo.density_matrix_to_pauli_basis(self.proc_data_dict['rho'])
nr_qubits = self.proc_data_dict['d'].bit_length() - 1
labels = list(itertools.product(*[['I', 'X', 'Y', 'Z']]*nr_qubits))
labels = [''.join(label_list) for label_list in labels]
if nr_qubits == 1:
order = [1, 2, 3]
elif nr_qubits == 2:
order = [1, 2, 3, 4, 8, 12, 5, 6, 7, 9, 10, 11, 13, 14, 15]
elif nr_qubits == 3:
order = [1, 2, 3, 4, 8, 12, 16, 32, 48] + \
[5, 6, 7, 9, 10, 11, 13, 14, 15] + \
[17, 18, 19, 33, 34, 35, 49, 50, 51] + \
[20, 24, 28, 36, 40, 44, 52, 56, 60] + \
[21, 22, 23, 25, 26, 27, 29, 30, 31] + \
[37, 38, 39, 41, 42, 43, 45, 46, 47] + \
[53, 54, 55, 57, 58, 59, 61, 62, 63]
else:
order = np.arange(4**nr_qubits)[1:]
if self.options_dict.get('pauli_raw', False):
fit_type = 'raw counts'
elif self.options_dict.get('pauli_values', False):
fit_type = 'corrected counts'
elif self.options_dict.get('mle', False):
fit_type = 'maximum likelihood estimation'
elif self.options_dict.get('imle', False):
fit_type = 'iterative maximum likelihood estimation'
else:
fit_type = 'least squares fit'
meas_string = self.base_analysis. \
raw_data_dict['measurementstring']
if np.ndim(meas_string) > 0:
if len(meas_string) > 1:
meas_string = meas_string[0] + ' to ' + meas_string[-1]
else:
meas_string = meas_string[0]
self.plot_dicts['pauli_basis'] = {
'plotfn': self.plot_bar,
'xcenters': np.arange(len(order)),
'xwidth': 0.4,
'xrange': (-1, len(order)),
'yvals': np.array(yexp)[order],
'xlabel': r'Pauli operator, $\hat{O}$',
'ylabel': r'Expectation value, $\mathrm{Tr}(\hat{O} \hat{\rho})$',
'title': 'Pauli operators, ' + fit_type + '\n' +
self.raw_data_dict['timestamp'] + ' ' + meas_string,
'yrange': (-1.1, 1.1),
'xtick_loc': np.arange(4**nr_qubits - 1),
'xtick_rotation': 90,
'xtick_labels': np.array(labels)[order],
'bar_kws': dict(zorder=10),
'setlabel': 'Fit to experiment',
'do_legend': True
}
if nr_qubits > 2:
self.plot_dicts['pauli_basis']['plotsize'] = (10, 5)
rho_target = self.raw_data_dict['exp_metadata'].get('rho_target', None)
rho_target = self.options_dict.get('rho_target', rho_target)
if rho_target is not None:
rho_target = qtp.Qobj(rho_target)
ytar = tomo.density_matrix_to_pauli_basis(rho_target)
self.plot_dicts['pauli_basis_target'] = {
'plotfn': self.plot_bar,
'ax_id': 'pauli_basis',
'xcenters': np.arange(len(order)),
'xwidth': 0.8,
'yvals': np.array(ytar)[order],
'xtick_loc': np.arange(len(order)),
'xtick_labels': np.array(labels)[order],
'bar_kws': dict(color='0.8', zorder=0),
'setlabel': 'Target values',
'do_legend': True
}
purity_str = r'Purity, $Tr(\rho^2) = {:.1f}\%$'.format(
100 * self.proc_data_dict['purity'])
if rho_target is not None:
fidelity_str = '\n' + r'Fidelity, $F = {:.1f}\%$'.format(
100 * self.proc_data_dict['fidelity'])
else:
fidelity_str = ''
if self.proc_data_dict['d'] == 4:
concurrence_str = '\n' + r'Concurrence, $C = {:.1f}\%$'.format(
100 * self.proc_data_dict['concurrence'])
else:
concurrence_str = ''
self.plot_dicts['pauli_info_labels'] = {
'ax_id': 'pauli_basis',
'plotfn': self.plot_line,
'xvals': [0],
'yvals': [0],
'line_kws': {'alpha': 0},
'setlabel': purity_str + fidelity_str,
'do_legend': True
}
def default_phase_cmap(self):
cols = np.array(((41, 39, 231), (61, 130, 163), (208, 170, 39),
(209, 126, 4), (181, 28, 20), (238, 76, 152),
(251, 130, 242), (162, 112, 251))) / 255
n = len(cols)
cdict = {
'red': [[i/n, cols[i%n][0], cols[i%n][0]] for i in range(n+1)],
'green': [[i/n, cols[i%n][1], cols[i%n][1]] for i in range(n+1)],
'blue': [[i/n, cols[i%n][2], cols[i%n][2]] for i in range(n+1)],
}
return mpl.colors.LinearSegmentedColormap('DMDefault', cdict)
class ReadoutROPhotonsAnalysis(Single_Qubit_TimeDomainAnalysis):
"""
Analyses the photon number in the RO based on the
readout_photons_in_resonator function
function specific options for options dict:
f_qubit
chi
artif_detuning
print_fit_results
"""
def __init__(self, t_start: str=None, t_stop: str=None,
label: str='', data_file_path: str=None,
close_figs: bool=False, options_dict: dict=None,
extract_only: bool=False, do_fitting: bool=False,
auto: bool=True):
super().__init__(t_start=t_start, t_stop=t_stop,
data_file_path=data_file_path,
options_dict=options_dict,
close_figs=close_figs, label=label,
extract_only=extract_only, do_fitting=do_fitting)
if self.options_dict.get('TwoD', None) is None:
self.options_dict['TwoD'] = True
self.label = label
self.params_dict = {
'measurementstring': 'measurementstring',
'sweep_points': 'sweep_points',
'sweep_points_2D': 'sweep_points_2D',
'value_names': 'value_names',
'value_units': 'value_units',
'measured_values': 'measured_values'}
self.numeric_params = self.options_dict.get('numeric_params',
OrderedDict())
self.kappa = self.options_dict.get('kappa_effective', None)
self.chi = self.options_dict.get('chi', None)
self.T2 = self.options_dict.get('T2echo', None)
self.artif_detuning = self.options_dict.get('artif_detuning', 0)
if (self.kappa is None) or (self.chi is None) or (self.T2 is None):
raise ValueError('kappa_effective, chi and T2echo must be passed to '
'the options_dict.')
if auto:
self.run_analysis()
def process_data(self):
self.proc_data_dict = OrderedDict()
self.proc_data_dict['qubit_state'] = [[],[]]
self.proc_data_dict['delay_to_relax'] = self.raw_data_dict[
'sweep_points_2D'][0]
self.proc_data_dict['ramsey_times'] = []
for i,x in enumerate(np.transpose(self.raw_data_dict[
'measured_data']['raw w0 _measure'][0])):
self.proc_data_dict['qubit_state'][0].append([])
self.proc_data_dict['qubit_state'][1].append([])
for j,y in enumerate(np.transpose(self.raw_data_dict[
'measured_data']['raw w0 _measure'][0])[i]):
if j%2 == 0:
self.proc_data_dict['qubit_state'][0][i].append(y)
else:
self.proc_data_dict['qubit_state'][1][i].append(y)
for i,x in enumerate( self.raw_data_dict['sweep_points'][0]):
if i % 2 == 0:
self.proc_data_dict['ramsey_times'].append(x)
#I STILL NEED to pass Chi
def prepare_fitting(self):
self.proc_data_dict['photon_number'] = [[],[]]
self.proc_data_dict['fit_results'] = []
self.proc_data_dict['ramsey_fit_results'] = [[],[]]
for i,tau in enumerate(self.proc_data_dict['delay_to_relax']):
self.proc_data_dict['ramsey_fit_results'][0].append(self.fit_Ramsey(
self.proc_data_dict['ramsey_times'][:-4],
self.proc_data_dict['qubit_state'][0][i][:-4]/
max(self.proc_data_dict['qubit_state'][0][i][:-4]),
state=0,
kw=self.options_dict))
self.proc_data_dict['ramsey_fit_results'][1].append(self.fit_Ramsey(
self.proc_data_dict['ramsey_times'][:-4],
self.proc_data_dict['qubit_state'][1][i][:-4]/
max(self.proc_data_dict['qubit_state'][1][i][:-4]),
state=1,
kw=self.options_dict))
n01 = self.proc_data_dict['ramsey_fit_results'
][0][i][0].params['n0'].value
n02 = self.proc_data_dict['ramsey_fit_results'
][1][i][0].params['n0'].value
self.proc_data_dict['photon_number'][0].append(n01)
self.proc_data_dict['photon_number'][1].append(n02)
def run_fitting(self):
print_fit_results = self.params_dict.pop('print_fit_results',False)
exp_dec_mod = lmfit.Model(fit_mods.ExpDecayFunc)
exp_dec_mod.set_param_hint('n',
value=1,
vary=False)
exp_dec_mod.set_param_hint('offset',
value=0,
min=0,
vary=True)
exp_dec_mod.set_param_hint('tau',
value=self.proc_data_dict[
'delay_to_relax'][-1],
min=1e-11,
vary=True)
exp_dec_mod.set_param_hint('amplitude',
value=1,
min=0,
vary=True)
params = exp_dec_mod.make_params()
self.fit_res = OrderedDict()
self.fit_res['ground_state'] = exp_dec_mod.fit(
data=self.proc_data_dict['photon_number'][0],
params=params,
t=self.proc_data_dict['delay_to_relax'])
self.fit_res['excited_state'] = exp_dec_mod.fit(
data=self.proc_data_dict['photon_number'][1],
params=params,
t=self.proc_data_dict['delay_to_relax'])
if print_fit_results:
print(self.fit_res['ground_state'].fit_report())
print(self.fit_res['excited_state'].fit_report())
def fit_Ramsey(self, x, y, state, **kw):
x = np.array(x)
y = np.array(y)
exp_dec_p_mod = lmfit.Model(fit_mods.ExpDecayPmod)
comb_exp_dec_mod = lmfit.Model(fit_mods.CombinedOszExpDecayFunc)
average = np.mean(y)
ft_of_data = np.fft.fft(y)
index_of_fourier_maximum = np.argmax(np.abs(
ft_of_data[1:len(ft_of_data) // 2])) + 1
max_ramsey_delay = x[-1] - x[0]
fft_axis_scaling = 1 / max_ramsey_delay
freq_est = fft_axis_scaling * index_of_fourier_maximum
n_est = (freq_est-self.artif_detuning)/(2 * self.chi)
exp_dec_p_mod.set_param_hint('T2echo',
value=self.T2,
vary=False)
exp_dec_p_mod.set_param_hint('offset',
value=average,
min=0,
vary=True)
exp_dec_p_mod.set_param_hint('delta',
value=self.artif_detuning,
vary=False)
exp_dec_p_mod.set_param_hint('amplitude',
value=1,
min=0,
vary=True)
exp_dec_p_mod.set_param_hint('kappa',
value=self.kappa[state],
vary=False)
exp_dec_p_mod.set_param_hint('chi',
value=self.chi,
vary=False)
exp_dec_p_mod.set_param_hint('n0',
value=n_est,
min=0,
vary=True)
exp_dec_p_mod.set_param_hint('phase',
value=0,
vary=True)
comb_exp_dec_mod.set_param_hint('tau',
value=self.T2,
vary=True)
comb_exp_dec_mod.set_param_hint('offset',
value=average,
min=0,
vary=True)
comb_exp_dec_mod.set_param_hint('oscillation_offset',
value=average,
min=0,
vary=True)
comb_exp_dec_mod.set_param_hint('amplitude',
value=1,
min=0,
vary=True)
comb_exp_dec_mod.set_param_hint('tau_gauss',
value=self.kappa[state],
vary=True)
comb_exp_dec_mod.set_param_hint('n0',
value=n_est,
min=0,
vary=True)
comb_exp_dec_mod.set_param_hint('phase',
value=0,
vary=True)
comb_exp_dec_mod.set_param_hint('delta',
value=self.artif_detuning,
vary=False)
comb_exp_dec_mod.set_param_hint('chi',
value=self.chi,
vary=False)
if (np.average(y[:4]) >
np.average(y[4:8])):
phase_estimate = 0
else:
phase_estimate = np.pi
exp_dec_p_mod.set_param_hint('phase',
value=phase_estimate, vary=True)
comb_exp_dec_mod.set_param_hint('phase',
value=phase_estimate, vary=True)
amplitude_guess = 0.5
if np.all(np.logical_and(y >= 0, y <= 1)):
exp_dec_p_mod.set_param_hint('amplitude',
value=amplitude_guess,
min=0.00,
max=4.0,
vary=True)
comb_exp_dec_mod.set_param_hint('amplitude',
value=amplitude_guess,
min=0.00,
max=4.0,
vary=True)
else:
print('data is not normalized, varying amplitude')
exp_dec_p_mod.set_param_hint('amplitude',
value=max(y),
min=0.00,
max=4.0,
vary=True)
comb_exp_dec_mod.set_param_hint('amplitude',
value=max(y),
min=0.00,
max=4.0,
vary=True)
fit_res_1 = exp_dec_p_mod.fit(data=y,
t=x,
params= exp_dec_p_mod.make_params())
fit_res_2 = comb_exp_dec_mod.fit(data=y,
t=x,
params= comb_exp_dec_mod.make_params())
if fit_res_1.chisqr > .35:
log.warning('Fit did not converge, varying phase')
fit_res_lst = []
for phase_estimate in np.linspace(0, 2*np.pi, 10):
for i, del_amp in enumerate(np.linspace(
-max(y)/10, max(y)/10, 10)):
exp_dec_p_mod.set_param_hint('phase',
value=phase_estimate,
vary=False)
exp_dec_p_mod.set_param_hint('amplitude',
value=max(y)+ del_amp)
fit_res_lst += [exp_dec_p_mod.fit(
data=y,
t=x,
params= exp_dec_p_mod.make_params())]
chisqr_lst = [fit_res_1.chisqr for fit_res_1 in fit_res_lst]
fit_res_1 = fit_res_lst[np.argmin(chisqr_lst)]
if fit_res_2.chisqr > .35:
log.warning('Fit did not converge, varying phase')
fit_res_lst = []
for phase_estimate in np.linspace(0, 2*np.pi, 10):
for i, del_amp in enumerate(np.linspace(
-max(y)/10, max(y)/10, 10)):
comb_exp_dec_mod.set_param_hint('phase',
value=phase_estimate,
vary=False)
comb_exp_dec_mod.set_param_hint('amplitude',
value=max(y)+ del_amp)
fit_res_lst += [comb_exp_dec_mod.fit(
data=y,
t=x,
params= comb_exp_dec_mod.make_params())]
chisqr_lst = [fit_res_2.chisqr for fit_res_2 in fit_res_lst]
fit_res_2 = fit_res_lst[np.argmin(chisqr_lst)]
if fit_res_1.chisqr < fit_res_2.chisqr:
self.proc_data_dict['params'] = exp_dec_p_mod.make_params()
return [fit_res_1,fit_res_1,fit_res_2]
else:
self.proc_data_dict['params'] = comb_exp_dec_mod.make_params()
return [fit_res_2,fit_res_1,fit_res_2]
def prepare_plots(self):
self.prepare_2D_sweep_plot()
self.prepare_photon_number_plot()
self.prepare_ramsey_plots()
def prepare_2D_sweep_plot(self):
self.plot_dicts['off_full_data_'+self.label] = {
'title': 'Raw data |g>',
'plotfn': self.plot_colorxy,
'xvals': self.proc_data_dict['ramsey_times'],
'xlabel': 'Ramsey delays',
'xunit': 's',
'yvals': self.proc_data_dict['delay_to_relax'],
'ylabel': 'Delay after first RO-pulse',
'yunit': 's',
'zvals': np.array(self.proc_data_dict['qubit_state'][0]) }
self.plot_dicts['on_full_data_'+self.label] = {
'title': 'Raw data |e>',
'plotfn': self.plot_colorxy,
'xvals': self.proc_data_dict['ramsey_times'],
'xlabel': 'Ramsey delays',
'xunit': 's',
'yvals': self.proc_data_dict['delay_to_relax'],
'ylabel': 'Delay after first RO-pulse',
'yunit': 's',
'zvals': np.array(self.proc_data_dict['qubit_state'][1]) }
def prepare_ramsey_plots(self):
x_fit = np.linspace(self.proc_data_dict['ramsey_times'][0],
max(self.proc_data_dict['ramsey_times']),101)
for i in range(len(self.proc_data_dict['ramsey_fit_results'][0])):
self.plot_dicts['off_'+str(i)] = {
'title': 'Ramsey w t_delay = '+\
str(self.proc_data_dict['delay_to_relax'][i])+ \
' s, in |g> state',
'ax_id':'ramsey_off_'+str(i),
'plotfn': self.plot_line,
'xvals': self.proc_data_dict['ramsey_times'],
'xlabel': 'Ramsey delays',
'xunit': 's',
'yvals': np.array(self.proc_data_dict['qubit_state'][0][i]/
max(self.proc_data_dict['qubit_state'][0][i][:-4])),
'ylabel': 'Measured qubit state',
'yunit': '',
'marker': 'o',
'setlabel': '|g> data_'+str(i),
'do_legend': True }
self.plot_dicts['off_fit_'+str(i)] = {
'title': 'Ramsey w t_delay = '+ \
str(self.proc_data_dict['delay_to_relax'][i])+ \
' s, in |g> state',
'ax_id':'ramsey_off_'+str(i),
'plotfn': self.plot_line,
'xvals': x_fit,
'yvals': self.proc_data_dict['ramsey_fit_results'][0][i][1].eval(
self.proc_data_dict['ramsey_fit_results'][0][i][1].params,
t=x_fit),
'linestyle': '-',
'marker': '',
'setlabel': '|g> fit_model'+str(i),
'do_legend': True }
self.plot_dicts['off_fit_2_'+str(i)] = {
'title': 'Ramsey w t_delay = '+ \
str(self.proc_data_dict['delay_to_relax'][i])+ \
' s, in |g> state',
'ax_id':'ramsey_off_'+str(i),
'plotfn': self.plot_line,
'xvals': x_fit,
'yvals': self.proc_data_dict['ramsey_fit_results'][0][i][2].eval(
self.proc_data_dict['ramsey_fit_results'][0][i][2].params,
t=x_fit),
'linestyle': '-',
'marker': '',
'setlabel': '|g> fit_simpel_model'+str(i),
'do_legend': True }
self.plot_dicts['hidden_g_'+str(i)] = {
'ax_id':'ramsey_off_'+str(i),
'plotfn': self.plot_line,
'xvals': [0],
'yvals': [0],
'color': 'w',
'setlabel': 'Residual photon count = '
''+str(self.proc_data_dict['photon_number'][0][i]),
'do_legend': True }
self.plot_dicts['on_'+str(i)] = {
'title': 'Ramsey w t_delay = '+ \
str(self.proc_data_dict['delay_to_relax'][i])+ \
' s, in |e> state',
'ax_id':'ramsey_on_'+str(i),
'plotfn': self.plot_line,
'xvals': self.proc_data_dict['ramsey_times'],
'xlabel': 'Ramsey delays',
'xunit': 's',
'yvals': np.array(self.proc_data_dict['qubit_state'][1][i]/
max(self.proc_data_dict['qubit_state'][1][i][:-4])),
'ylabel': 'Measured qubit state',
'yunit': '',
'marker': 'o',
'setlabel': '|e> data_'+str(i),
'do_legend': True }
self.plot_dicts['on_fit_'+str(i)] = {
'title': 'Ramsey w t_delay = '+ \
str(self.proc_data_dict['delay_to_relax'][i])+ \
' s, in |e> state',
'ax_id':'ramsey_on_'+str(i),
'plotfn': self.plot_line,
'xvals': x_fit,
'yvals': self.proc_data_dict['ramsey_fit_results'][1][i][1].eval(
self.proc_data_dict['ramsey_fit_results'][1][i][1].params,
t=x_fit),
'linestyle': '-',
'marker': '',
'setlabel': '|e> fit_model'+str(i),
'do_legend': True }
self.plot_dicts['on_fit_2_'+str(i)] = {
'title': 'Ramsey w t_delay = '+ \
str(self.proc_data_dict['delay_to_relax'][i])+ \
' s, in |e> state',
'ax_id':'ramsey_on_'+str(i),
'plotfn': self.plot_line,
'xvals': x_fit,
'yvals': self.proc_data_dict['ramsey_fit_results'][1][i][2].eval(
self.proc_data_dict['ramsey_fit_results'][1][i][2].params,
t=x_fit),
'linestyle': '-',
'marker': '',
'setlabel': '|e> fit_simpel_model'+str(i),
'do_legend': True }
self.plot_dicts['hidden_e_'+str(i)] = {
'ax_id':'ramsey_on_'+str(i),
'plotfn': self.plot_line,
'xvals': [0],
'yvals': [0],
'color': 'w',
'setlabel': 'Residual photon count = '
''+str(self.proc_data_dict['photon_number'][1][i]),
'do_legend': True }
def prepare_photon_number_plot(self):
ylabel = 'Average photon number'
yunit = ''
x_fit = np.linspace(min(self.proc_data_dict['delay_to_relax']),
max(self.proc_data_dict['delay_to_relax']),101)
minmax_data = [min(min(self.proc_data_dict['photon_number'][0]),
min(self.proc_data_dict['photon_number'][1])),
max(max(self.proc_data_dict['photon_number'][0]),
max(self.proc_data_dict['photon_number'][1]))]
minmax_data[0] -= minmax_data[0]/5
minmax_data[1] += minmax_data[1]/5
self.proc_data_dict['photon_number'][1],
self.fit_res['excited_state'].eval(
self.fit_res['excited_state'].params,
t=x_fit)
self.plot_dicts['Photon number count'] = {
'plotfn': self.plot_line,
'xlabel': 'Delay after first RO-pulse',
'ax_id': 'Photon number count ',
'xunit': 's',
'xvals': self.proc_data_dict['delay_to_relax'],
'yvals': self.proc_data_dict['photon_number'][0],
'ylabel': ylabel,
'yunit': yunit,
'yrange': minmax_data,
'title': 'Residual photon number',
'color': 'b',
'linestyle': '',
'marker': 'o',
'setlabel': '|g> data',
'func': 'semilogy',
'do_legend': True}
self.plot_dicts['main2'] = {
'plotfn': self.plot_line,
'xunit': 's',
'xvals': x_fit,
'yvals': self.fit_res['ground_state'].eval(
self.fit_res['ground_state'].params,
t=x_fit),
'yrange': minmax_data,
'ax_id': 'Photon number count ',
'color': 'b',
'linestyle': '-',
'marker': '',
'setlabel': '|g> fit',
'func': 'semilogy',
'do_legend': True}
self.plot_dicts['main3'] = {
'plotfn': self.plot_line,
'xunit': 's',
'xvals': self.proc_data_dict['delay_to_relax'],
'yvals': self.proc_data_dict['photon_number'][1],
'yrange': minmax_data,
'ax_id': 'Photon number count ',
'color': 'r',
'linestyle': '',
'marker': 'o',
'setlabel': '|e> data',
'func': 'semilogy',
'do_legend': True}
self.plot_dicts['main4'] = {
'plotfn': self.plot_line,
'xunit': 's',
'ax_id': 'Photon number count ',
'xvals': x_fit,
'yvals': self.fit_res['excited_state'].eval(
self.fit_res['excited_state'].params,
t=x_fit),
'yrange': minmax_data,
'ylabel': ylabel,
'color': 'r',
'linestyle': '-',
'marker': '',
'setlabel': '|e> fit',
'func': 'semilogy',
'do_legend': True}
self.plot_dicts['hidden_1'] = {
'ax_id': 'Photon number count ',
'plotfn': self.plot_line,
'yrange': minmax_data,
'xvals': [0],
'yvals': [0],
'color': 'w',
'setlabel': 'tau_g = '
''+str("%.3f" %
(self.fit_res['ground_state'].params['tau'].value*1e9))+''
' ns',
'do_legend': True }
self.plot_dicts['hidden_2'] = {
'ax_id': 'Photon number count ',
'plotfn': self.plot_line,
'yrange': minmax_data,
'xvals': [0],
'yvals': [0],
'color': 'w',
'setlabel': 'tau_e = '
''+str("%.3f" %
(self.fit_res['excited_state'].params['tau'].value*1e9))+''
' ns',
'do_legend': True}
class RODynamicPhaseAnalysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, qb_names: list=None, t_start: str=None, t_stop: str=None,
data_file_path: str=None, single_timestamp: bool=False,
options_dict: dict=None, extract_only: bool=False,
do_fitting: bool=True, auto=True):
super().__init__(qb_names=qb_names, t_start=t_start, t_stop=t_stop,
data_file_path=data_file_path,
options_dict=options_dict,
extract_only=extract_only,
do_fitting=do_fitting,
auto=False)
if auto:
self.run_analysis()
def process_data(self):
super().process_data()
if 'qbp_name' in self.metadata:
self.pulsed_qbname = self.metadata['qbp_name']
else:
self.pulsed_qbname = self.options_dict.get('pulsed_qbname')
self.measured_qubits = [qbn for qbn in self.channel_map if
qbn != self.pulsed_qbname]
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
for qbn in self.measured_qubits:
ro_dict = self.proc_data_dict['projected_data_dict'][qbn]
sweep_points = self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points']
for ro_suff, data in ro_dict.items():
cos_mod = lmfit.Model(fit_mods.CosFunc)
if self.num_cal_points != 0:
data = data[:-self.num_cal_points]
guess_pars = fit_mods.Cos_guess(
model=cos_mod,
t=sweep_points,
data=data)
guess_pars['amplitude'].vary = True
guess_pars['offset'].vary = True
guess_pars['frequency'].vary = True
guess_pars['phase'].vary = True
key = 'cos_fit_{}{}'.format(qbn, ro_suff)
self.fit_dicts[key] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': sweep_points},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
self.dynamic_phases = OrderedDict()
for meas_qbn in self.measured_qubits:
self.dynamic_phases[meas_qbn] = \
(self.fit_dicts['cos_fit_{}_measure'.format(meas_qbn)][
'fit_res'].best_values['phase'] -
self.fit_dicts['cos_fit_{}_ref_measure'.format(meas_qbn)][
'fit_res'].best_values['phase'])*180/np.pi
def prepare_plots(self):
super().prepare_plots()
if self.do_fitting:
for meas_qbn in self.measured_qubits:
sweep_points_dict = self.proc_data_dict['sweep_points_dict'][
meas_qbn]
if self.num_cal_points != 0:
yvals = [self.proc_data_dict['projected_data_dict'][meas_qbn][
'_ref_measure'][:-self.num_cal_points],
self.proc_data_dict['projected_data_dict'][meas_qbn][
'_measure'][:-self.num_cal_points]]
sweep_points = sweep_points_dict['msmt_sweep_points']
# plot cal points
for i, cal_pts_idxs in enumerate(
self.cal_states_dict.values()):
key = list(self.cal_states_dict)[i] + meas_qbn
self.plot_dicts[key] = {
'fig_id': 'dyn_phase_plot_' + meas_qbn,
'plotfn': self.plot_line,
'xvals': np.mean([
sweep_points_dict['cal_points_sweep_points'][
cal_pts_idxs],
sweep_points_dict['cal_points_sweep_points'][
cal_pts_idxs]],
axis=0),
'yvals': np.mean([
self.proc_data_dict['projected_data_dict'][meas_qbn][
'_ref_measure'][cal_pts_idxs],
self.proc_data_dict['projected_data_dict'][meas_qbn][
'_measure'][cal_pts_idxs]],
axis=0),
'setlabel': list(self.cal_states_dict)[i],
'do_legend': True,
'legend_bbox_to_anchor': (1, 0.5),
'legend_pos': 'center left',
'linestyle': 'none',
'line_kws': {'color': self.get_cal_state_color(
list(self.cal_states_dict)[i])}}
else:
yvals = [self.proc_data_dict['projected_data_dict'][meas_qbn][
'_ref_measure'],
self.proc_data_dict['projected_data_dict'][meas_qbn][
'_measure']]
sweep_points = sweep_points_dict['sweep_points']
self.plot_dicts['dyn_phase_plot_' + meas_qbn] = {
'plotfn': self.plot_line,
'xvals': [sweep_points, sweep_points],
'xlabel': self.raw_data_dict['xlabel'][0],
'xunit': self.raw_data_dict['xunit'][0][0],
'yvals': yvals,
'ylabel': 'Excited state population',
'yunit': '',
'setlabel': ['with measurement', 'no measurement'],
'title': (self.raw_data_dict['timestamps'][0] + ' ' +
self.raw_data_dict['measurementstring'][0]),
'linestyle': 'none',
'do_legend': True,
'legend_bbox_to_anchor': (1, 0.5),
'legend_pos': 'center left'}
self.plot_dicts['cos_fit_' + meas_qbn + '_ref_measure'] = {
'fig_id': 'dyn_phase_plot_' + meas_qbn,
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['cos_fit_{}_ref_measure'.format(
meas_qbn)]['fit_res'],
'setlabel': 'cos fit',
'do_legend': True,
'legend_bbox_to_anchor': (1, 0.5),
'legend_pos': 'center left'}
self.plot_dicts['cos_fit_' + meas_qbn + '_measure'] = {
'fig_id': 'dyn_phase_plot_' + meas_qbn,
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['cos_fit_{}_measure'.format(
meas_qbn)]['fit_res'],
'setlabel': 'cos fit',
'do_legend': True,
'legend_bbox_to_anchor': (1, 0.5),
'legend_pos': 'center left'}
textstr = 'Dynamic phase = {:.2f}'.format(
self.dynamic_phases[meas_qbn]) + r'$^{\circ}$'
self.plot_dicts['text_msg_' + meas_qbn] = {
'fig_id': 'dyn_phase_plot_' + meas_qbn,
'ypos': -0.175,
'xpos': 0.5,
'horizontalalignment': 'center',
'verticalalignment': 'top',
'plotfn': self.plot_text,
'text_string': textstr}
class FluxAmplitudeSweepAnalysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, qb_names, *args, **kwargs):
self.mask_freq = kwargs.pop('mask_freq', None)
self.mask_amp = kwargs.pop('mask_amp', None)
super().__init__(qb_names, *args, **kwargs)
def extract_data(self):
super().extract_data()
# Set some default values specific to FluxPulseScopeAnalysis if the
# respective options have not been set by the user or in the metadata.
# (We do not do this in the init since we have to wait until
# metadata has been extracted.)
if self.get_param_value('rotation_type', default_value=None) is None:
self.options_dict['rotation_type'] = 'global_PCA'
if self.get_param_value('TwoD', default_value=None) is None:
self.options_dict['TwoD'] = True
def process_data(self):
super().process_data()
pdd = self.proc_data_dict
nr_sp = {qb: len(pdd['sweep_points_dict'][qb]['sweep_points'])
for qb in self.qb_names}
nr_sp2d = {qb: len(list(pdd['sweep_points_2D_dict'][qb].values())[0])
for qb in self.qb_names}
nr_cp = self.num_cal_points
# make matrix out of vector
data_reshaped = {qb: np.reshape(deepcopy(
pdd['data_to_fit'][qb]).T.flatten(), (nr_sp[qb], nr_sp2d[qb]))
for qb in self.qb_names}
pdd['data_reshaped'] = data_reshaped
# remove calibration points from data to fit
data_no_cp = {qb: np.array([pdd['data_reshaped'][qb][i, :]
for i in range(nr_sp[qb]-nr_cp)])
for qb in self.qb_names}
# apply mask
for qb in self.qb_names:
if self.mask_freq is None:
self.mask_freq = [True]*nr_sp2d[qb] # by default, no point is masked
if self.mask_amp is None:
self.mask_amp = [True]*(nr_sp[qb]-nr_cp)
pdd['freqs_masked'] = {}
pdd['amps_masked'] = {}
pdd['data_masked'] = {}
for qb in self.qb_names:
sp_param = [k for k in self.mospm[qb] if 'freq' in k][0]
pdd['freqs_masked'][qb] = \
pdd['sweep_points_2D_dict'][qb][sp_param][self.mask_freq]
pdd['amps_masked'][qb] = \
pdd['sweep_points_dict'][qb]['sweep_points'][
:-self.num_cal_points][self.mask_amp]
data_masked = data_no_cp[qb][self.mask_amp,:]
pdd['data_masked'][qb] = data_masked[:, self.mask_freq]
def prepare_fitting(self):
pdd = self.proc_data_dict
self.fit_dicts = OrderedDict()
# Gaussian fit of amplitude slices
gauss_mod = fit_mods.GaussianModel_v2()
for qb in self.qb_names:
for i in range(len(pdd['amps_masked'][qb])):
data = pdd['data_masked'][qb][i,:]
self.fit_dicts[f'gauss_fit_{qb}_{i}'] = {
'model': gauss_mod,
'fit_xvals': {'x': pdd['freqs_masked'][qb]},
'fit_yvals': {'data': data}
}
def analyze_fit_results(self):
pdd = self.proc_data_dict
pdd['gauss_center'] = {}
pdd['gauss_center_err'] = {}
pdd['filtered_center'] = {}
pdd['filtered_amps'] = {}
for qb in self.qb_names:
pdd['gauss_center'][qb] = np.array([
self.fit_res[f'gauss_fit_{qb}_{i}'].best_values['center']
for i in range(len(pdd['amps_masked'][qb]))])
pdd['gauss_center_err'][qb] = np.array([
self.fit_res[f'gauss_fit_{qb}_{i}'].params['center'].stderr
for i in range(len(pdd['amps_masked'][qb]))])
# filter out points with stderr > 1e6 Hz
pdd['filtered_center'][qb] = np.array([])
pdd['filtered_amps'][qb] = np.array([])
for i, stderr in enumerate(pdd['gauss_center_err'][qb]):
try:
if stderr < 1e6:
pdd['filtered_center'][qb] = \
np.append(pdd['filtered_center'][qb],
pdd['gauss_center'][qb][i])
pdd['filtered_amps'][qb] = \
np.append(pdd['filtered_amps'][qb],
pdd['sweep_points_dict'][qb]\
['sweep_points'][:-self.num_cal_points][i])
except:
continue
# if gaussian fitting does not work (i.e. all points were filtered
# out above) use max value of data to get an estimate of freq
if len(pdd['filtered_amps'][qb]) == 0:
for qb in self.qb_names:
freqs = np.array([])
for i in range(pdd['data_masked'][qb].shape[0]):
freqs = np.append(freqs, pdd['freqs_masked'][qb]\
[np.argmax(pdd['data_masked'][qb][i,:])])
pdd['filtered_center'][qb] = freqs
pdd['filtered_amps'][qb] = pdd['amps_masked'][qb]
# fit the freqs to the qubit model
self.fit_func = self.get_param_value('fit_func', fit_mods.Qubit_dac_to_freq)
if self.fit_func == fit_mods.Qubit_dac_to_freq_precise:
fit_guess_func = fit_mods.Qubit_dac_arch_guess_precise
else:
fit_guess_func = fit_mods.Qubit_dac_arch_guess
freq_mod = lmfit.Model(self.fit_func)
fixed_params = \
self.get_param_value("fixed_params_for_fit", {}).get(qb, None)
if fixed_params is None:
fixed_params = dict(E_c=0)
freq_mod.guess = fit_guess_func.__get__(
freq_mod, freq_mod.__class__)
self.fit_dicts[f'freq_fit_{qb}'] = {
'model': freq_mod,
'fit_xvals': {'dac_voltage': pdd['filtered_amps'][qb]},
'fit_yvals': {'data': pdd['filtered_center'][qb]},
"guessfn_pars": {"fixed_params": fixed_params}}
self.run_fitting()
def prepare_plots(self):
pdd = self.proc_data_dict
rdd = self.raw_data_dict
for qb in self.qb_names:
sp_param = [k for k in self.mospm[qb] if 'freq' in k][0]
self.plot_dicts[f'data_2d_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'],
'ax_id': f'data_2d_{qb}',
'plotfn': self.plot_colorxy,
'xvals': pdd['sweep_points_dict'][qb]['sweep_points'],
'yvals': pdd['sweep_points_2D_dict'][qb][sp_param],
'zvals': np.transpose(pdd['data_reshaped'][qb]),
'xlabel': r'Flux pulse amplitude',
'xunit': 'V',
'ylabel': r'Qubit drive frequency',
'yunit': 'Hz',
'zlabel': 'Excited state population',
}
if self.do_fitting:
if self.options_dict.get('scatter', True):
label = f'freq_scatter_{qb}_scatter'
self.plot_dicts[label] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'],
'ax_id': f'data_2d_{qb}',
'plotfn': self.plot_line,
'linestyle': '',
'marker': 'o',
'xvals': pdd['filtered_amps'][qb],
'yvals': pdd['filtered_center'][qb],
'xlabel': r'Flux pulse amplitude',
'xunit': 'V',
'ylabel': r'Qubit drive frequency',
'yunit': 'Hz',
'color': 'white',
}
amps = pdd['sweep_points_dict'][qb]['sweep_points'][
:-self.num_cal_points]
label = f'freq_scatter_{qb}'
self.plot_dicts[label] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'],
'ax_id': f'data_2d_{qb}',
'plotfn': self.plot_line,
'linestyle': '-',
'marker': '',
'xvals': amps,
'yvals': self.fit_func(amps,
**self.fit_res[f'freq_fit_{qb}'].best_values),
'color': 'red',
}
class T1FrequencySweepAnalysis(MultiQubit_TimeDomain_Analysis):
def process_data(self):
super().process_data()
pdd = self.proc_data_dict
nr_cp = self.num_cal_points
self.lengths = OrderedDict()
self.amps = OrderedDict()
self.freqs = OrderedDict()
for qbn in self.qb_names:
len_key = [pn for pn in self.mospm[qbn] if 'length' in pn]
if len(len_key) == 0:
raise KeyError('Couldn"t find sweep points corresponding to '
'flux pulse length.')
self.lengths[qbn] = self.sp.get_sweep_params_property(
'values', 0, len_key[0])
amp_key = [pn for pn in self.mospm[qbn] if 'amp' in pn]
if len(len_key) == 0:
raise KeyError('Couldn"t find sweep points corresponding to '
'flux pulse amplitude.')
self.amps[qbn] = self.sp.get_sweep_params_property(
'values', 1, amp_key[0])
freq_key = [pn for pn in self.mospm[qbn] if 'freq' in pn]
if len(freq_key) == 0:
self.freqs[qbn] = None
else:
self.freqs[qbn] =self.sp.get_sweep_params_property(
'values', 1, freq_key[0])
nr_amps = len(self.amps[self.qb_names[0]])
nr_lengths = len(self.lengths[self.qb_names[0]])
# make matrix out of vector
data_reshaped_no_cp = {qb: np.reshape(deepcopy(
pdd['data_to_fit'][qb][
:, :pdd['data_to_fit'][qb].shape[1]-nr_cp]).flatten(),
(nr_amps, nr_lengths)) for qb in self.qb_names}
pdd['data_reshaped_no_cp'] = data_reshaped_no_cp
pdd['mask'] = {qb: np.ones(nr_amps, dtype=np.bool)
for qb in self.qb_names}
def prepare_fitting(self):
pdd = self.proc_data_dict
self.fit_dicts = OrderedDict()
exp_mod = fit_mods.ExponentialModel()
for qb in self.qb_names:
for i, data in enumerate(pdd['data_reshaped_no_cp'][qb]):
self.fit_dicts[f'exp_fit_{qb}_amp_{i}'] = {
'model': exp_mod,
'fit_xvals': {'x': self.lengths[qb]},
'fit_yvals': {'data': data}}
def analyze_fit_results(self):
pdd = self.proc_data_dict
pdd['T1'] = {}
pdd['T1_err'] = {}
for qb in self.qb_names:
pdd['T1'][qb] = np.array([
abs(self.fit_res[f'exp_fit_{qb}_amp_{i}'].best_values['decay'])
for i in range(len(self.amps[qb]))])
pdd['T1_err'][qb] = np.array([
self.fit_res[f'exp_fit_{qb}_amp_{i}'].params['decay'].stderr
for i in range(len(self.amps[qb]))])
for i in range(len(self.amps[qb])):
try:
if pdd['T1_err'][qb][i] >= 10 * pdd['T1'][qb][i]:
pdd['mask'][qb][i] = False
except TypeError:
pdd['mask'][qb][i] = False
def prepare_plots(self):
pdd = self.proc_data_dict
rdd = self.raw_data_dict
for qb in self.qb_names:
for p, param_values in enumerate([self.amps, self.freqs]):
if param_values is None:
continue
suffix = '_amp' if p == 0 else '_freq'
mask = pdd['mask'][qb]
xlabel = r'Flux pulse amplitude' if p == 0 else \
r'Derived qubit frequency'
if self.do_fitting:
# Plot T1 vs flux pulse amplitude
label = f'T1_fit_{qb}{suffix}'
self.plot_dicts[label] = {
'title': rdd['measurementstring'] + '\n' + rdd['timestamp'],
'plotfn': self.plot_line,
'linestyle': '-',
'xvals': param_values[qb][mask],
'yvals': pdd['T1'][qb][mask],
'yerr': pdd['T1_err'][qb][mask],
'xlabel': xlabel,
'xunit': 'V' if p == 0 else 'Hz',
'ylabel': r'T1',
'yunit': 's',
'color': 'blue',
}
# Plot rotated integrated average in dependece of flux pulse
# amplitude and length
label = f'T1_color_plot_{qb}{suffix}'
self.plot_dicts[label] = {
'title': rdd['measurementstring'] + '\n' + rdd['timestamp'],
'plotfn': self.plot_colorxy,
'linestyle': '-',
'xvals': param_values[qb][mask],
'yvals': self.lengths[qb],
'zvals': np.transpose(pdd['data_reshaped_no_cp'][qb][mask]),
'xlabel': xlabel,
'xunit': 'V' if p == 0 else 'Hz',
'ylabel': r'Flux pulse length',
'yunit': 's',
'zlabel': r'Excited state population'
}
# Plot population loss for the first flux pulse length as a
# function of flux pulse amplitude
label = f'Pop_loss_{qb}{suffix}'
self.plot_dicts[label] = {
'title': rdd['measurementstring'] + '\n' + rdd['timestamp'],
'plotfn': self.plot_line,
'linestyle': '-',
'xvals': param_values[qb][mask],
'yvals': 1 - pdd['data_reshaped_no_cp'][qb][:, 0][mask],
'xlabel': xlabel,
'xunit': 'V' if p == 0 else 'Hz',
'ylabel': r'Pop. loss @ {:.0f} ns'.format(
self.lengths[qb][0]/1e-9
),
'yunit': '',
}
# Plot all fits in single figure
if self.options_dict.get('all_fits', False) and self.do_fitting:
colormap = self.options_dict.get('colormap', mpl.cm.plasma)
for i in range(len(self.amps[qb])):
color = colormap(i/(len(self.amps[qb])-1))
label = f'exp_fit_{qb}_amp_{i}'
fitid = param_values[qb][i]
self.plot_dicts[label] = {
'title': rdd['measurementstring'] + '\n' + rdd['timestamp'],
'fig_id': f'T1_fits_{qb}',
'xlabel': r'Flux pulse length',
'xunit': 's',
'ylabel': r'Excited state population',
'plotfn': self.plot_fit,
'fit_res': self.fit_res[label],
'plot_init': self.options_dict.get('plot_init', False),
'color': color,
'setlabel': f'freq={fitid:.4f}' if p == 1
else f'amp={fitid:.4f}',
'do_legend': False,
'legend_bbox_to_anchor': (1, 1),
'legend_pos': 'upper left',
}
label = f'freq_scatter_{qb}_{i}'
self.plot_dicts[label] = {
'fig_id': f'T1_fits_{qb}',
'plotfn': self.plot_line,
'xvals': self.lengths[qb],
'linestyle': '',
'yvals': pdd['data_reshaped_no_cp'][qb][i, :],
'color': color,
'setlabel': f'freq={fitid:.4f}' if p == 1
else f'amp={fitid:.4f}',
}
class T2FrequencySweepAnalysis(MultiQubit_TimeDomain_Analysis):
def process_data(self):
super().process_data()
pdd = self.proc_data_dict
nr_cp = self.num_cal_points
nr_amps = len(self.metadata['amplitudes'])
nr_lengths = len(self.metadata['flux_lengths'])
nr_phases = len(self.metadata['phases'])
# make matrix out of vector
data_reshaped_no_cp = {qb: np.reshape(
deepcopy(pdd['data_to_fit'][qb][
:, :pdd['data_to_fit'][qb].shape[1]-nr_cp]).flatten(),
(nr_amps, nr_lengths, nr_phases)) for qb in self.qb_names}
pdd['data_reshaped_no_cp'] = data_reshaped_no_cp
if self.metadata['use_cal_points']:
pdd['cal_point_data'] = {qb: deepcopy(
pdd['data_to_fit'][qb][
len(pdd['data_to_fit'][qb])-nr_cp:]) for qb in self.qb_names}
pdd['mask'] = {qb: np.ones(nr_amps, dtype=np.bool)
for qb in self.qb_names}
def prepare_fitting(self):
pdd = self.proc_data_dict
self.fit_dicts = OrderedDict()
nr_amps = len(self.metadata['amplitudes'])
for qb in self.qb_names:
for i in range(nr_amps):
for j, data in enumerate(pdd['data_reshaped_no_cp'][qb][i]):
cos_mod = fit_mods.CosModel
guess_pars = fit_mods.Cos_guess(
model=cos_mod, t=self.metadata['phases'],
data=data,
freq_guess=1/360)
guess_pars['frequency'].value = 1/360
guess_pars['frequency'].vary = False
self.fit_dicts[f'cos_fit_{qb}_{i}_{j}'] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': self.metadata['phases']},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
pdd = self.proc_data_dict
pdd['T2'] = {}
pdd['T2_err'] = {}
pdd['phase_contrast'] = {}
nr_lengths = len(self.metadata['flux_lengths'])
nr_amps = len(self.metadata['amplitudes'])
for qb in self.qb_names:
pdd['phase_contrast'][qb] = {}
exp_mod = fit_mods.ExponentialModel()
for i in range(nr_amps):
pdd['phase_contrast'][qb][f'amp_{i}'] = np.array([self.fit_res[
f'cos_fit_{qb}_{i}_{j}'
].best_values['amplitude']
for j in
range(nr_lengths)])
self.fit_dicts[f'exp_fit_{qb}_{i}'] = {
'model': exp_mod,
'fit_xvals': {'x': self.metadata['flux_lengths']},
'fit_yvals': {'data': np.array([self.fit_res[
f'cos_fit_{qb}_{i}_{j}'
].best_values['amplitude']
for j in
range(nr_lengths)])}}
self.run_fitting()
pdd['T2'][qb] = np.array([
abs(self.fit_res[f'exp_fit_{qb}_{i}'].best_values['decay'])
for i in range(len(self.metadata['amplitudes']))])
pdd['mask'][qb] = []
for i in range(len(self.metadata['amplitudes'])):
try:
if self.fit_res[f'exp_fit_{qb}_{i}']\
.params['decay'].stderr >= 1e-5:
pdd['mask'][qb][i] = False
except TypeError:
pdd['mask'][qb][i] = False
def prepare_plots(self):
pdd = self.proc_data_dict
rdd = self.raw_data_dict
for qb in self.qb_names:
mask = pdd['mask'][qb]
label = f'T2_fit_{qb}'
xvals = self.metadata['amplitudes'][mask] if \
self.metadata['frequencies'] is None else \
self.metadata['frequencies'][mask]
xlabel = r'Flux pulse amplitude' if \
self.metadata['frequencies'] is None else \
r'Derived qubit frequency'
self.plot_dicts[label] = {
'plotfn': self.plot_line,
'linestyle': '-',
'xvals': xvals,
'yvals': pdd['T2'][qb][mask],
'xlabel': xlabel,
'xunit': 'V' if self.metadata['frequencies'] is None else 'Hz',
'ylabel': r'T2',
'yunit': 's',
'color': 'blue',
}
# Plot all fits in single figure
if not self.options_dict.get('all_fits', False):
continue
colormap = self.options_dict.get('colormap', mpl.cm.plasma)
for i in range(len(self.metadata['amplitudes'])):
color = colormap(i/(len(self.metadata['frequencies'])-1))
label = f'exp_fit_{qb}_amp_{i}'
freqs = self.metadata['frequencies'] is not None
fitid = self.metadata.get('frequencies',
self.metadata['amplitudes'])[i]
self.plot_dicts[label] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'],
'ax_id': f'T2_fits_{qb}',
'xlabel': r'Flux pulse length',
'xunit': 's',
'ylabel': r'Excited state population',
'plotfn': self.plot_fit,
'fit_res': self.fit_res[label],
'plot_init': self.options_dict.get('plot_init', False),
'color': color,
'setlabel': f'freq={fitid:.4f}' if freqs
else f'amp={fitid:.4f}',
'do_legend': False,
'legend_bbox_to_anchor': (1, 1),
'legend_pos': 'upper left',
}
label = f'freq_scatter_{qb}_{i}'
self.plot_dicts[label] = {
'ax_id': f'T2_fits_{qb}',
'plotfn': self.plot_line,
'xvals': self.metadata['phases'],
'linestyle': '',
'yvals': pdd['data_reshaped_no_cp'][qb][i,:],
'color': color,
'setlabel': f'freq={fitid:.4f}' if freqs
else f'amp={fitid:.4f}',
}
class MeasurementInducedDephasingAnalysis(MultiQubit_TimeDomain_Analysis):
def process_data(self):
super().process_data()
rdd = self.raw_data_dict
pdd = self.proc_data_dict
pdd['data_reshaped'] = {qb: [] for qb in pdd['data_to_fit']}
pdd['amps_reshaped'] = np.unique(self.metadata['hard_sweep_params']['ro_amp_scale']['values'])
pdd['phases_reshaped'] = []
for amp in pdd['amps_reshaped']:
mask = self.metadata['hard_sweep_params']['ro_amp_scale']['values'] == amp
pdd['phases_reshaped'].append(self.metadata['hard_sweep_params']['phase']['values'][mask])
for qb in self.qb_names:
pdd['data_reshaped'][qb].append(pdd['data_to_fit'][qb][:len(mask)][mask])
def prepare_fitting(self):
pdd = self.proc_data_dict
rdd = self.raw_data_dict
self.fit_dicts = OrderedDict()
for qb in self.qb_names:
for i, data in enumerate(pdd['data_reshaped'][qb]):
cos_mod = fit_mods.CosModel
guess_pars = fit_mods.Cos_guess(
model=cos_mod, t=pdd['phases_reshaped'][i],
data=data, freq_guess=1/360)
guess_pars['frequency'].value = 1/360
guess_pars['frequency'].vary = False
self.fit_dicts[f'cos_fit_{qb}_{i}'] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': pdd['phases_reshaped'][i]},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
pdd = self.proc_data_dict
pdd['phase_contrast'] = {}
pdd['phase_offset'] = {}
pdd['sigma'] = {}
pdd['sigma_err'] = {}
pdd['a'] = {}
pdd['a_err'] = {}
pdd['c'] = {}
pdd['c_err'] = {}
for qb in self.qb_names:
pdd['phase_contrast'][qb] = np.array([
self.fit_res[f'cos_fit_{qb}_{i}'].best_values['amplitude']
for i, _ in enumerate(pdd['data_reshaped'][qb])])
pdd['phase_offset'][qb] = np.array([
self.fit_res[f'cos_fit_{qb}_{i}'].best_values['phase']
for i, _ in enumerate(pdd['data_reshaped'][qb])])
pdd['phase_offset'][qb] += np.pi * (pdd['phase_contrast'][qb] < 0)
pdd['phase_offset'][qb] = (pdd['phase_offset'][qb] + np.pi) % (2 * np.pi) - np.pi
pdd['phase_offset'][qb] = 180*np.unwrap(pdd['phase_offset'][qb])/np.pi
pdd['phase_contrast'][qb] = np.abs(pdd['phase_contrast'][qb])
gauss_mod = lmfit.models.GaussianModel()
self.fit_dicts[f'phase_contrast_fit_{qb}'] = {
'model': gauss_mod,
'guess_dict': {'center': {'value': 0, 'vary': False}},
'fit_xvals': {'x': pdd['amps_reshaped']},
'fit_yvals': {'data': pdd['phase_contrast'][qb]}}
quadratic_mod = lmfit.models.QuadraticModel()
self.fit_dicts[f'phase_offset_fit_{qb}'] = {
'model': quadratic_mod,
'guess_dict': {'b': {'value': 0, 'vary': False}},
'fit_xvals': {'x': pdd['amps_reshaped']},
'fit_yvals': {'data': pdd['phase_offset'][qb]}}
self.run_fitting()
self.save_fit_results()
pdd['sigma'][qb] = self.fit_res[f'phase_contrast_fit_{qb}'].best_values['sigma']
pdd['sigma_err'][qb] = self.fit_res[f'phase_contrast_fit_{qb}'].params['sigma']. \
stderr
pdd['a'][qb] = self.fit_res[f'phase_offset_fit_{qb}'].best_values['a']
pdd['a_err'][qb] = self.fit_res[f'phase_offset_fit_{qb}'].params['a'].stderr
pdd['c'][qb] = self.fit_res[f'phase_offset_fit_{qb}'].best_values['c']
pdd['c_err'][qb] = self.fit_res[f'phase_offset_fit_{qb}'].params['c'].stderr
pdd['sigma_err'][qb] = float('nan') if pdd['sigma_err'][qb] is None \
else pdd['sigma_err'][qb]
pdd['a_err'][qb] = float('nan') if pdd['a_err'][qb] is None else pdd['a_err'][qb]
pdd['c_err'][qb] = float('nan') if pdd['c_err'][qb] is None else pdd['c_err'][qb]
def prepare_plots(self):
pdd = self.proc_data_dict
rdd = self.raw_data_dict
phases_equal = True
for phases in pdd['phases_reshaped'][1:]:
if not np.all(phases == pdd['phases_reshaped'][0]):
phases_equal = False
break
for qb in self.qb_names:
if phases_equal:
self.plot_dicts[f'data_2d_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'],
'plotfn': self.plot_colorxy,
'xvals': pdd['phases_reshaped'][0],
'yvals': pdd['amps_reshaped'],
'zvals': pdd['data_reshaped'][qb],
'xlabel': r'Pulse phase, $\phi$',
'xunit': 'deg',
'ylabel': r'Readout pulse amplitude scale, $V_{RO}/V_{ref}$',
'yunit': '',
'zlabel': 'Excited state population',
}
colormap = self.options_dict.get('colormap', mpl.cm.plasma)
for i, amp in enumerate(pdd['amps_reshaped']):
color = colormap(i/(len(pdd['amps_reshaped'])-1))
label = f'cos_data_{qb}_{i}'
self.plot_dicts[label] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'],
'ax_id': f'amplitude_crossections_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['phases_reshaped'][i],
'yvals': pdd['data_reshaped'][qb][i],
'xlabel': r'Pulse phase, $\phi$',
'xunit': 'deg',
'ylabel': 'Excited state population',
'linestyle': '',
'color': color,
'setlabel': f'amp={amp:.4f}',
'do_legend': True,
'legend_bbox_to_anchor': (1, 1),
'legend_pos': 'upper left',
}
if self.do_fitting:
for i, amp in enumerate(pdd['amps_reshaped']):
color = colormap(i/(len(pdd['amps_reshaped'])-1))
label = f'cos_fit_{qb}_{i}'
self.plot_dicts[label] = {
'ax_id': f'amplitude_crossections_{qb}',
'plotfn': self.plot_fit,
'fit_res': self.fit_res[label],
'plot_init': self.options_dict.get('plot_init', False),
'color': color,
'setlabel': f'fit, amp={amp:.4f}',
}
# Phase contrast
self.plot_dicts[f'phase_contrast_data_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'],
'ax_id': f'phase_contrast_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['amps_reshaped'],
'yvals': 200*pdd['phase_contrast'][qb],
'xlabel': r'Readout pulse amplitude scale, $V_{RO}/V_{ref}$',
'xunit': '',
'ylabel': 'Phase contrast',
'yunit': '%',
'linestyle': '',
'color': 'k',
'setlabel': 'data',
'do_legend': True,
}
self.plot_dicts[f'phase_contrast_fit_{qb}'] = {
'ax_id': f'phase_contrast_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['amps_reshaped'],
'yvals': 200*self.fit_res[f'phase_contrast_fit_{qb}'].best_fit,
'color': 'r',
'marker': '',
'setlabel': 'fit',
'do_legend': True,
}
self.plot_dicts[f'phase_contrast_labels_{qb}'] = {
'ax_id': f'phase_contrast_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['amps_reshaped'],
'yvals': 200*pdd['phase_contrast'][qb],
'marker': '',
'linestyle': '',
'setlabel': r'$\sigma = ({:.5f} \pm {:.5f})$ V'.
format(pdd['sigma'][qb], pdd['sigma_err'][qb]),
'do_legend': True,
'legend_bbox_to_anchor': (1, 1),
'legend_pos': 'upper left',
}
# Phase offset
self.plot_dicts[f'phase_offset_data_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'],
'ax_id': f'phase_offset_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['amps_reshaped'],
'yvals': pdd['phase_offset'][qb],
'xlabel': r'Readout pulse amplitude scale, $V_{RO}/V_{ref}$',
'xunit': '',
'ylabel': 'Phase offset',
'yunit': 'deg',
'linestyle': '',
'color': 'k',
'setlabel': 'data',
'do_legend': True,
}
self.plot_dicts[f'phase_offset_fit_{qb}'] = {
'ax_id': f'phase_offset_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['amps_reshaped'],
'yvals': self.fit_res[f'phase_offset_fit_{qb}'].best_fit,
'color': 'r',
'marker': '',
'setlabel': 'fit',
'do_legend': True,
}
self.plot_dicts[f'phase_offset_labels_{qb}'] = {
'ax_id': f'phase_offset_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['amps_reshaped'],
'yvals': pdd['phase_offset'][qb],
'marker': '',
'linestyle': '',
'setlabel': r'$a = {:.0f} \pm {:.0f}$ deg/V${{}}^2$'.
format(pdd['a'][qb], pdd['a_err'][qb]) + '\n' +
r'$c = {:.1f} \pm {:.1f}$ deg'.
format(pdd['c'][qb], pdd['c_err'][qb]),
'do_legend': True,
'legend_bbox_to_anchor': (1, 1),
'legend_pos': 'upper left',
}
class DriveCrosstalkCancellationAnalysis(MultiQubit_TimeDomain_Analysis):
def process_data(self):
super().process_data()
if self.sp is None:
raise ValueError('This analysis needs a SweepPoints '
'class instance.')
pdd = self.proc_data_dict
# get the ramsey phases as the values of the first sweep parameter
# in the 2nd sweep dimension.
# !!! This assumes all qubits have the same ramsey phases !!!
pdd['ramsey_phases'] = self.sp.get_sweep_params_property('values', 1)
pdd['qb_sweep_points'] = {}
pdd['qb_sweep_param'] = {}
for k, v in self.sp.get_sweep_dimension(0).items():
if k == 'phase':
continue
qb, param = k.split('.')
pdd['qb_sweep_points'][qb] = v[0]
pdd['qb_sweep_param'][qb] = (param, v[1], v[2])
pdd['qb_msmt_vals'] = {}
pdd['qb_cal_vals'] = {}
for qb, data in pdd['data_to_fit'].items():
pdd['qb_msmt_vals'][qb] = data[:, :-self.num_cal_points].reshape(
len(pdd['qb_sweep_points'][qb]), len(pdd['ramsey_phases']))
pdd['qb_cal_vals'][qb] = data[0, -self.num_cal_points:]
def prepare_fitting(self):
pdd = self.proc_data_dict
self.fit_dicts = OrderedDict()
for qb in self.qb_names:
for i, data in enumerate(pdd['qb_msmt_vals'][qb]):
cos_mod = fit_mods.CosModel
guess_pars = fit_mods.Cos_guess(
model=cos_mod, t=pdd['ramsey_phases'],
data=data, freq_guess=1/360)
guess_pars['frequency'].value = 1/360
guess_pars['frequency'].vary = False
self.fit_dicts[f'cos_fit_{qb}_{i}'] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': pdd['ramsey_phases']},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
pdd = self.proc_data_dict
pdd['phase_contrast'] = {}
pdd['phase_offset'] = {}
for qb in self.qb_names:
pdd['phase_contrast'][qb] = np.array([
2*self.fit_res[f'cos_fit_{qb}_{i}'].best_values['amplitude']
for i, _ in enumerate(pdd['qb_msmt_vals'][qb])])
pdd['phase_offset'][qb] = np.array([
self.fit_res[f'cos_fit_{qb}_{i}'].best_values['phase']
for i, _ in enumerate(pdd['qb_msmt_vals'][qb])])
pdd['phase_offset'][qb] *= 180/np.pi
pdd['phase_offset'][qb] += 180 * (pdd['phase_contrast'][qb] < 0)
pdd['phase_offset'][qb] = (pdd['phase_offset'][qb] + 180) % 360 - 180
pdd['phase_contrast'][qb] = np.abs(pdd['phase_contrast'][qb])
def prepare_plots(self):
pdd = self.proc_data_dict
rdd = self.raw_data_dict
for qb in self.qb_names:
self.plot_dicts[f'data_2d_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'] + '\n' + qb,
'plotfn': self.plot_colorxy,
'xvals': pdd['ramsey_phases'],
'yvals': pdd['qb_sweep_points'][qb],
'zvals': pdd['qb_msmt_vals'][qb],
'xlabel': r'Ramsey phase, $\phi$',
'xunit': 'deg',
'ylabel': pdd['qb_sweep_param'][qb][2],
'yunit': pdd['qb_sweep_param'][qb][1],
'zlabel': 'Excited state population',
}
colormap = self.options_dict.get('colormap', mpl.cm.plasma)
for i, pval in enumerate(pdd['qb_sweep_points'][qb]):
if i == len(pdd['qb_sweep_points'][qb]) - 1:
legendlabel='data, ref.'
else:
legendlabel = f'data, {pdd["qb_sweep_param"][qb][0]}='\
f'{pval:.4f}{pdd["qb_sweep_param"][qb][1]}'
color = colormap(i/(len(pdd['qb_sweep_points'][qb])-1))
label = f'cos_data_{qb}_{i}'
self.plot_dicts[label] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'] + '\n' + qb,
'ax_id': f'param_crossections_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['ramsey_phases'],
'yvals': pdd['qb_msmt_vals'][qb][i],
'xlabel': r'Ramsey phase, $\phi$',
'xunit': 'deg',
'ylabel': 'Excited state population',
'linestyle': '',
'color': color,
'setlabel': legendlabel,
'do_legend': False,
'legend_bbox_to_anchor': (1, 1),
'legend_pos': 'upper left',
}
if self.do_fitting:
for i, pval in enumerate(pdd['qb_sweep_points'][qb]):
if i == len(pdd['qb_sweep_points'][qb]) - 1:
legendlabel = 'fit, ref.'
else:
legendlabel = f'fit, {pdd["qb_sweep_param"][qb][0]}='\
f'{pval:.4f}{pdd["qb_sweep_param"][qb][1]}'
color = colormap(i/(len(pdd['qb_sweep_points'][qb])-1))
label = f'cos_fit_{qb}_{i}'
self.plot_dicts[label] = {
'ax_id': f'param_crossections_{qb}',
'plotfn': self.plot_fit,
'fit_res': self.fit_res[label],
'plot_init': self.options_dict.get('plot_init', False),
'color': color,
'do_legend': False,
# 'setlabel': legendlabel
}
# Phase contrast
self.plot_dicts[f'phase_contrast_data_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'] + '\n' + qb,
'ax_id': f'phase_contrast_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['qb_sweep_points'][qb][:-1],
'yvals': pdd['phase_contrast'][qb][:-1] * 100,
'xlabel': pdd['qb_sweep_param'][qb][2],
'xunit': pdd['qb_sweep_param'][qb][1],
'ylabel': 'Phase contrast',
'yunit': '%',
'linestyle': '-',
'marker': 'o',
'color': 'C0',
'setlabel': 'data',
'do_legend': True,
}
self.plot_dicts[f'phase_contrast_ref_{qb}'] = {
'ax_id': f'phase_contrast_{qb}',
'plotfn': self.plot_hlines,
'xmin': pdd['qb_sweep_points'][qb][:-1].min(),
'xmax': pdd['qb_sweep_points'][qb][:-1].max(),
'y': pdd['phase_contrast'][qb][-1] * 100,
'linestyle': '--',
'colors': '0.6',
'setlabel': 'ref',
'do_legend': True,
}
# Phase offset
self.plot_dicts[f'phase_offset_data_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'] + '\n' + qb,
'ax_id': f'phase_offset_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['qb_sweep_points'][qb][:-1],
'yvals': pdd['phase_offset'][qb][:-1],
'xlabel': pdd['qb_sweep_param'][qb][2],
'xunit': pdd['qb_sweep_param'][qb][1],
'ylabel': 'Phase offset',
'yunit': 'deg',
'linestyle': '-',
'marker': 'o',
'color': 'C0',
'setlabel': 'data',
'do_legend': True,
}
self.plot_dicts[f'phase_offset_ref_{qb}'] = {
'ax_id': f'phase_offset_{qb}',
'plotfn': self.plot_hlines,
'xmin': pdd['qb_sweep_points'][qb][:-1].min(),
'xmax': pdd['qb_sweep_points'][qb][:-1].max(),
'y': pdd['phase_offset'][qb][-1],
'linestyle': '--',
'colors': '0.6',
'setlabel': 'ref',
'do_legend': True,
}
class FluxlineCrosstalkAnalysis(MultiQubit_TimeDomain_Analysis):
"""Analysis for the measure_fluxline_crosstalk measurement.
The measurement involves Ramsey measurements on a set of crosstalk qubits,
which have been brought to a flux-sensitive position with a flux pulse.
The first dimension is the ramsey-phase of these qubits.
In the second sweep dimension, the amplitude of a flux pulse on another
(target) qubit is swept.
The analysis extracts the change in Ramsey phase offset, which gets
converted to a frequency offset due to the flux pulse on the target qubit.
The frequency offset is then converted to a flux offset, which is a measure
of the crosstalk between the target fluxline and the crosstalk qubit.
The measurement is hard-compressed, meaning the raw data is inherently 1d,
with one set of calibration points as the final segments. The experiment
part of the measured values are reshaped to the correct 2d shape for
the analysis. The sweep points passed into the analysis should still reflect
the 2d nature of the measurement, meaning the ramsey phase values should be
passed in the first dimension and the target fluxpulse amplitudes in the
second sweep dimension.
"""
def __init__(self, qb_names, *args, **kwargs):
params_dict = {f'{qbn}.amp_to_freq_model':
f'Instrument settings.{qbn}.fit_ge_freq_from_flux_pulse_amp'
for qbn in qb_names}
kwargs['params_dict'] = kwargs.get('params_dict', {})
kwargs['params_dict'].update(params_dict)
super().__init__(qb_names, *args, **kwargs)
def process_data(self):
super().process_data()
if self.sp is None:
raise ValueError('This analysis needs a SweepPoints '
'class instance.')
pdd = self.proc_data_dict
pdd['ramsey_phases'] = self.sp.get_sweep_params_property('values', 0)
pdd['target_amps'] = self.sp.get_sweep_params_property('values', 1)
pdd['target_fluxpulse_length'] = \
self.get_param_value('target_fluxpulse_length')
pdd['crosstalk_qubits_amplitudes'] = \
self.get_param_value('crosstalk_qubits_amplitudes')
pdd['qb_msmt_vals'] = {qb:
pdd['data_to_fit'][qb][:, :-self.num_cal_points].reshape(
len(pdd['target_amps']), len(pdd['ramsey_phases']))
for qb in self.qb_names}
pdd['qb_cal_vals'] = {
qb: pdd['data_to_fit'][qb][0, -self.num_cal_points:]
for qb in self.qb_names}
def prepare_fitting(self):
pdd = self.proc_data_dict
self.fit_dicts = OrderedDict()
cos_mod = lmfit.Model(fit_mods.CosFunc)
cos_mod.guess = fit_mods.Cos_guess.__get__(cos_mod, cos_mod.__class__)
for qb in self.qb_names:
for i, data in enumerate(pdd['qb_msmt_vals'][qb]):
self.fit_dicts[f'cos_fit_{qb}_{i}'] = {
'model': cos_mod,
'guess_dict': {'frequency': {'value': 1 / 360,
'vary': False}},
'fit_xvals': {'t': pdd['ramsey_phases']},
'fit_yvals': {'data': data}}
def analyze_fit_results(self):
pdd = self.proc_data_dict
pdd['phase_contrast'] = {}
pdd['phase_offset'] = {}
pdd['freq_offset'] = {}
pdd['freq'] = {}
self.skip_qb_freq_fits = self.get_param_value('skip_qb_freq_fits', False)
if not self.skip_qb_freq_fits:
pdd['flux'] = {}
for qb in self.qb_names:
pdd['phase_contrast'][qb] = np.array([
2 * self.fit_res[f'cos_fit_{qb}_{i}'].best_values['amplitude']
for i, _ in enumerate(pdd['qb_msmt_vals'][qb])])
pdd['phase_offset'][qb] = np.array([
self.fit_res[f'cos_fit_{qb}_{i}'].best_values['phase']
for i, _ in enumerate(pdd['qb_msmt_vals'][qb])])
pdd['phase_offset'][qb] *= 180 / np.pi
pdd['phase_offset'][qb] += 180 * (pdd['phase_contrast'][qb] < 0)
pdd['phase_offset'][qb] = (pdd['phase_offset'][qb] + 180) % 360 - 180
pdd['phase_offset'][qb] = \
np.unwrap(pdd['phase_offset'][qb] / 180 * np.pi) * 180 / np.pi
pdd['phase_contrast'][qb] = np.abs(pdd['phase_contrast'][qb])
pdd['freq_offset'][qb] = pdd['phase_offset'][qb] / 360 / pdd[
'target_fluxpulse_length']
fr = lmfit.Model(lambda a, f_a=1, f0=0: a * f_a + f0).fit(
data=pdd['freq_offset'][qb], a=pdd['target_amps'])
pdd['freq_offset'][qb] -= fr.best_values['f0']
if not self.skip_qb_freq_fits:
mpars = eval(self.raw_data_dict[f'{qb}.amp_to_freq_model'])
freq_idle = fit_mods.Qubit_dac_to_freq(
pdd['crosstalk_qubits_amplitudes'].get(qb, 0), **mpars)
pdd['freq'][qb] = pdd['freq_offset'][qb] + freq_idle
mpars.update({'V_per_phi0': 1, 'dac_sweet_spot': 0})
pdd['flux'][qb] = fit_mods.Qubit_freq_to_dac(
pdd['freq'][qb], **mpars)
# fit fitted results to linear models
lin_mod = lmfit.Model(lambda x, a=1, b=0: a*x + b)
def guess(model, data, x, **kwargs):
a_guess = (data[-1] - data[0])/(x[-1] - x[0])
b_guess = data[0] - x[0]*a_guess
return model.make_params(a=a_guess, b=b_guess)
lin_mod.guess = guess.__get__(lin_mod, lin_mod.__class__)
keys_to_fit = []
for qb in self.qb_names:
for param in ['phase_offset', 'freq_offset', 'flux']:
if param == 'flux' and self.skip_qb_freq_fits:
continue
key = f'{param}_fit_{qb}'
self.fit_dicts[key] = {
'model': lin_mod,
'fit_xvals': {'x': pdd['target_amps']},
'fit_yvals': {'data': pdd[param][qb]}}
keys_to_fit.append(key)
self.run_fitting(keys_to_fit=keys_to_fit)
def prepare_plots(self):
pdd = self.proc_data_dict
rdd = self.raw_data_dict
for qb in self.qb_names:
self.plot_dicts[f'data_2d_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'] + '\n' + qb,
'plotfn': self.plot_colorxy,
'xvals': pdd['ramsey_phases'],
'yvals': pdd['target_amps'],
'zvals': pdd['qb_msmt_vals'][qb],
'xlabel': r'Ramsey phase, $\phi$',
'xunit': 'deg',
'ylabel': self.sp.get_sweep_params_property('label', 1,
'target_amp'),
'yunit': self.sp.get_sweep_params_property('unit', 1,
'target_amp'),
'zlabel': 'Excited state population',
}
colormap = self.options_dict.get('colormap', mpl.cm.plasma)
for i, pval in enumerate(pdd['target_amps']):
legendlabel = f'data, amp. = {pval:.4f} V'
color = colormap(i / (len(pdd['target_amps']) - 1))
label = f'cos_data_{qb}_{i}'
self.plot_dicts[label] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'] + '\n' + qb,
'ax_id': f'param_crossections_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['ramsey_phases'],
'yvals': pdd['qb_msmt_vals'][qb][i],
'xlabel': r'Ramsey phase, $\phi$',
'xunit': 'deg',
'ylabel': 'Excited state population',
'linestyle': '',
'color': color,
'setlabel': legendlabel,
'do_legend': False,
'legend_bbox_to_anchor': (1, 1),
'legend_pos': 'upper left',
}
if self.do_fitting:
for i, pval in enumerate(pdd['target_amps']):
legendlabel = f'fit, amp. = {pval:.4f} V'
color = colormap(i / (len(pdd['target_amps']) - 1))
label = f'cos_fit_{qb}_{i}'
self.plot_dicts[label] = {
'ax_id': f'param_crossections_{qb}',
'plotfn': self.plot_fit,
'fit_res': self.fit_res[label],
'plot_init': self.options_dict.get('plot_init', False),
'color': color,
'setlabel': legendlabel,
'do_legend': False,
}
# Phase contrast
self.plot_dicts[f'phase_contrast_data_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'] + '\n' + qb,
'ax_id': f'phase_contrast_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['target_amps'],
'yvals': pdd['phase_contrast'][qb] * 100,
'xlabel':self.sp.get_sweep_params_property('label', 1,
'target_amp'),
'xunit': self.sp.get_sweep_params_property('unit', 1,
'target_amp'),
'ylabel': 'Phase contrast',
'yunit': '%',
'linestyle': '-',
'marker': 'o',
'color': 'C0',
}
# Phase offset
self.plot_dicts[f'phase_offset_data_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'] + '\n' + qb,
'ax_id': f'phase_offset_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['target_amps'],
'yvals': pdd['phase_offset'][qb],
'xlabel':self.sp.get_sweep_params_property('label', 1,
'target_amp'),
'xunit': self.sp.get_sweep_params_property('unit', 1,
'target_amp'),
'ylabel': 'Phase offset',
'yunit': 'deg',
'linestyle': 'none',
'marker': 'o',
'color': 'C0',
}
# Frequency offset
self.plot_dicts[f'freq_offset_data_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'] + '\n' + qb,
'ax_id': f'freq_offset_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['target_amps'],
'yvals': pdd['freq_offset'][qb],
'xlabel':self.sp.get_sweep_params_property('label', 1,
'target_amp'),
'xunit': self.sp.get_sweep_params_property('unit', 1,
'target_amp'),
'ylabel': 'Freq. offset, $\\Delta f$',
'yunit': 'Hz',
'linestyle': 'none',
'marker': 'o',
'color': 'C0',
}
if not self.skip_qb_freq_fits:
# Flux
self.plot_dicts[f'flux_data_{qb}'] = {
'title': rdd['measurementstring'] +
'\n' + rdd['timestamp'] + '\n' + qb,
'ax_id': f'flux_{qb}',
'plotfn': self.plot_line,
'xvals': pdd['target_amps'],
'yvals': pdd['flux'][qb],
'xlabel': self.sp[1]['target_amp'][2],
'xunit': self.sp[1]['target_amp'][1],
'ylabel': 'Flux, $\\Phi$',
'yunit': '$\\Phi_0$',
'linestyle': 'none',
'marker': 'o',
'color': 'C0',
}
for param in ['phase_offset', 'freq_offset', 'flux']:
if param == 'flux' and self.skip_qb_freq_fits:
continue
self.plot_dicts[f'{param}_fit_{qb}'] = {
'ax_id': f'{param}_{qb}',
'plotfn': self.plot_fit,
'fit_res': self.fit_res[f'{param}_fit_{qb}'],
'plot_init': self.options_dict.get('plot_init', False),
'linestyle': '-',
'marker': '',
'color': 'C1',
}
class RabiAnalysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, qb_names, *args, **kwargs):
params_dict = {}
for qbn in qb_names:
s = 'Instrument settings.'+qbn
for trans_name in ['ge', 'ef']:
params_dict[f'{trans_name}_amp180_'+qbn] = \
s+f'.{trans_name}_amp180'
params_dict[f'{trans_name}_amp90scale_'+qbn] = \
s+f'.{trans_name}_amp90_scale'
kwargs['params_dict'] = params_dict
kwargs['numeric_params'] = list(params_dict)
super().__init__(qb_names, *args, **kwargs)
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
for qbn in self.qb_names:
data = self.proc_data_dict['data_to_fit'][qbn]
sweep_points = self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points']
if self.num_cal_points != 0:
data = data[:-self.num_cal_points]
cos_mod = lmfit.Model(fit_mods.CosFunc)
guess_pars = fit_mods.Cos_guess(
model=cos_mod, t=sweep_points, data=data)
guess_pars['amplitude'].vary = True
guess_pars['amplitude'].min = -10
guess_pars['offset'].vary = True
guess_pars['frequency'].vary = True
guess_pars['phase'].vary = True
self.set_user_guess_pars(guess_pars)
key = 'cos_fit_' + qbn
self.fit_dicts[key] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': sweep_points},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
self.proc_data_dict['analysis_params_dict'] = OrderedDict()
for qbn in self.qb_names:
fit_res = self.fit_dicts['cos_fit_' + qbn]['fit_res']
sweep_points = self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points']
self.proc_data_dict['analysis_params_dict'][qbn] = \
self.get_amplitudes(fit_res=fit_res, sweep_points=sweep_points)
self.save_processed_data(key='analysis_params_dict')
def get_amplitudes(self, fit_res, sweep_points):
# Extract the best fitted frequency and phase.
freq_fit = fit_res.best_values['frequency']
phase_fit = fit_res.best_values['phase']
freq_std = fit_res.params['frequency'].stderr
phase_std = fit_res.params['phase'].stderr
# If fitted_phase<0, shift fitted_phase by 4. This corresponds to a
# shift of 2pi in the argument of cos.
if np.abs(phase_fit) < 0.1:
phase_fit = 0
# If phase_fit<1, the piHalf amplitude<0.
if phase_fit < 1:
log.info('The data could not be fitted correctly. '
'The fitted phase "%s" <1, which gives '
'negative piHalf '
'amplitude.' % phase_fit)
stepsize = sweep_points[1] - sweep_points[0]
if freq_fit > 2 * stepsize:
log.info('The data could not be fitted correctly. The '
'frequency "%s" is too high.' % freq_fit)
n = np.arange(-2, 10)
piPulse_vals = (n*np.pi - phase_fit)/(2*np.pi*freq_fit)
piHalfPulse_vals = (n*np.pi + np.pi/2 - phase_fit)/(2*np.pi*freq_fit)
# find piHalfPulse
try:
piHalfPulse = \
np.min(piHalfPulse_vals[piHalfPulse_vals >= sweep_points[1]])
n_piHalf_pulse = n[piHalfPulse_vals==piHalfPulse]
except ValueError:
piHalfPulse = np.asarray([])
if piHalfPulse.size == 0 or piHalfPulse > max(sweep_points):
i = 0
while (piHalfPulse_vals[i] < min(sweep_points) and
i<piHalfPulse_vals.size):
i+=1
piHalfPulse = piHalfPulse_vals[i]
n_piHalf_pulse = n[i]
# find piPulse
try:
if piHalfPulse.size != 0:
piPulse = \
np.min(piPulse_vals[piPulse_vals >= piHalfPulse])
else:
piPulse = np.min(piPulse_vals[piPulse_vals >= 0.001])
n_pi_pulse = n[piHalfPulse_vals == piHalfPulse]
except ValueError:
piPulse = np.asarray([])
if piPulse.size == 0:
i = 0
while (piPulse_vals[i] < min(sweep_points) and
i < piPulse_vals.size):
i += 1
piPulse = piPulse_vals[i]
n_pi_pulse = n[i]
try:
freq_idx = fit_res.var_names.index('frequency')
phase_idx = fit_res.var_names.index('phase')
if fit_res.covar is not None:
cov_freq_phase = fit_res.covar[freq_idx, phase_idx]
else:
cov_freq_phase = 0
except ValueError:
cov_freq_phase = 0
try:
piPulse_std = self.calculate_pulse_stderr(
f=freq_fit,
phi=phase_fit,
f_err=freq_std,
phi_err=phase_std,
period_num=n_pi_pulse,
cov=cov_freq_phase)
piHalfPulse_std = self.calculate_pulse_stderr(
f=freq_fit,
phi=phase_fit,
f_err=freq_std,
phi_err=phase_std,
period_num=n_piHalf_pulse,
cov=cov_freq_phase)
except Exception as e:
log.error(e)
piPulse_std = 0
piHalfPulse_std = 0
rabi_amplitudes = {'piPulse': piPulse,
'piPulse_stderr': piPulse_std,
'piHalfPulse': piHalfPulse,
'piHalfPulse_stderr': piHalfPulse_std}
return rabi_amplitudes
def calculate_pulse_stderr(self, f, phi, f_err, phi_err,
period_num, cov=0):
x = period_num + phi
return np.sqrt((f_err*x/(2*np.pi*(f**2)))**2 +
(phi_err/(2*np.pi*f))**2 -
2*(cov**2)*x/((2*np.pi*(f**3))**2))[0]
def prepare_plots(self):
super().prepare_plots()
if self.do_fitting:
for qbn in self.qb_names:
base_plot_name = 'Rabi_' + qbn
self.prepare_projected_data_plot(
fig_name=base_plot_name,
data=self.proc_data_dict['data_to_fit'][qbn],
plot_name_suffix=qbn+'fit',
qb_name=qbn)
fit_res = self.fit_dicts['cos_fit_' + qbn]['fit_res']
self.plot_dicts['fit_' + qbn] = {
'fig_id': base_plot_name,
'plotfn': self.plot_fit,
'fit_res': fit_res,
'setlabel': 'cosine fit',
'color': 'r',
'do_legend': True,
'legend_ncol': 2,
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'}
rabi_amplitudes = self.proc_data_dict['analysis_params_dict']
self.plot_dicts['piamp_marker_' + qbn] = {
'fig_id': base_plot_name,
'plotfn': self.plot_line,
'xvals': np.array([rabi_amplitudes[qbn]['piPulse']]),
'yvals': np.array([fit_res.model.func(
rabi_amplitudes[qbn]['piPulse'],
**fit_res.best_values)]),
'setlabel': '$\pi$-Pulse amp',
'color': 'r',
'marker': 'o',
'line_kws': {'markersize': 10},
'linestyle': '',
'do_legend': True,
'legend_ncol': 2,
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'}
self.plot_dicts['piamp_hline_' + qbn] = {
'fig_id': base_plot_name,
'plotfn': self.plot_hlines,
'y': [fit_res.model.func(
rabi_amplitudes[qbn]['piPulse'],
**fit_res.best_values)],
'xmin': self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'][0],
'xmax': self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'][-1],
'colors': 'gray'}
self.plot_dicts['pihalfamp_marker_' + qbn] = {
'fig_id': base_plot_name,
'plotfn': self.plot_line,
'xvals': np.array([rabi_amplitudes[qbn]['piHalfPulse']]),
'yvals': np.array([fit_res.model.func(
rabi_amplitudes[qbn]['piHalfPulse'],
**fit_res.best_values)]),
'setlabel': '$\pi /2$-Pulse amp',
'color': 'm',
'marker': 'o',
'line_kws': {'markersize': 10},
'linestyle': '',
'do_legend': True,
'legend_ncol': 2,
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'}
self.plot_dicts['pihalfamp_hline_' + qbn] = {
'fig_id': base_plot_name,
'plotfn': self.plot_hlines,
'y': [fit_res.model.func(
rabi_amplitudes[qbn]['piHalfPulse'],
**fit_res.best_values)],
'xmin': self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'][0],
'xmax': self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'][-1],
'colors': 'gray'}
trans_name = 'ef' if 'f' in self.data_to_fit[qbn] else 'ge'
old_pipulse_val = self.raw_data_dict[
f'{trans_name}_amp180_'+qbn]
if old_pipulse_val != old_pipulse_val:
old_pipulse_val = 0
old_pihalfpulse_val = self.raw_data_dict[
f'{trans_name}_amp90scale_'+qbn]
if old_pihalfpulse_val != old_pihalfpulse_val:
old_pihalfpulse_val = 0
old_pihalfpulse_val *= old_pipulse_val
textstr = (' $\pi-Amp$ = {:.3f} V'.format(
rabi_amplitudes[qbn]['piPulse']) +
' $\pm$ {:.3f} V '.format(
rabi_amplitudes[qbn]['piPulse_stderr']) +
'\n$\pi/2-Amp$ = {:.3f} V '.format(
rabi_amplitudes[qbn]['piHalfPulse']) +
' $\pm$ {:.3f} V '.format(
rabi_amplitudes[qbn]['piHalfPulse_stderr']) +
'\n $\pi-Amp_{old}$ = ' + '{:.3f} V '.format(
old_pipulse_val) +
'\n$\pi/2-Amp_{old}$ = ' + '{:.3f} V '.format(
old_pihalfpulse_val))
self.plot_dicts['text_msg_' + qbn] = {
'fig_id': base_plot_name,
'ypos': -0.2,
'xpos': 0,
'horizontalalignment': 'left',
'verticalalignment': 'top',
'plotfn': self.plot_text,
'text_string': textstr}
class T1Analysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, qb_names, *args, **kwargs):
params_dict = {}
for qbn in qb_names:
s = 'Instrument settings.'+qbn
for trans_name in ['ge', 'ef']:
params_dict[f'{trans_name}_T1_'+qbn] = s+'.T1{}'.format(
'_ef' if trans_name == 'ef' else '')
kwargs['params_dict'] = params_dict
kwargs['numeric_params'] = list(params_dict)
super().__init__(qb_names, *args, **kwargs)
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
for qbn in self.qb_names:
data = self.proc_data_dict['data_to_fit'][qbn]
sweep_points = self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points']
if self.num_cal_points != 0:
data = data[:-self.num_cal_points]
exp_decay_mod = lmfit.Model(fit_mods.ExpDecayFunc)
guess_pars = fit_mods.exp_dec_guess(
model=exp_decay_mod, data=data, t=sweep_points)
guess_pars['amplitude'].vary = True
guess_pars['tau'].vary = True
if self.options_dict.get('vary_offset', False):
guess_pars['offset'].vary = True
else:
guess_pars['offset'].value = 0
guess_pars['offset'].vary = False
self.set_user_guess_pars(guess_pars)
key = 'exp_decay_' + qbn
self.fit_dicts[key] = {
'fit_fn': exp_decay_mod.func,
'fit_xvals': {'t': sweep_points},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
self.proc_data_dict['analysis_params_dict'] = OrderedDict()
for qbn in self.qb_names:
self.proc_data_dict['analysis_params_dict'][qbn] = OrderedDict()
self.proc_data_dict['analysis_params_dict'][qbn]['T1'] = \
self.fit_dicts['exp_decay_' + qbn]['fit_res'].best_values['tau']
self.proc_data_dict['analysis_params_dict'][qbn]['T1_stderr'] = \
self.fit_dicts['exp_decay_' + qbn]['fit_res'].params[
'tau'].stderr
self.save_processed_data(key='analysis_params_dict')
def prepare_plots(self):
super().prepare_plots()
if self.do_fitting:
for qbn in self.qb_names:
# rename base plot
base_plot_name = 'T1_' + qbn
self.prepare_projected_data_plot(
fig_name=base_plot_name,
data=self.proc_data_dict['data_to_fit'][qbn],
plot_name_suffix=qbn+'fit',
qb_name=qbn)
self.plot_dicts['fit_' + qbn] = {
'fig_id': base_plot_name,
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['exp_decay_' + qbn]['fit_res'],
'setlabel': 'exp decay fit',
'do_legend': True,
'color': 'r',
'legend_ncol': 2,
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'}
trans_name = 'ef' if 'f' in self.data_to_fit[qbn] else 'ge'
old_T1_val = self.raw_data_dict[f'{trans_name}_T1_'+qbn]
if old_T1_val != old_T1_val:
old_T1_val = 0
T1_dict = self.proc_data_dict['analysis_params_dict']
textstr = '$T_1$ = {:.2f} $\mu$s'.format(
T1_dict[qbn]['T1']*1e6) \
+ ' $\pm$ {:.2f} $\mu$s'.format(
T1_dict[qbn]['T1_stderr']*1e6) \
+ '\nold $T_1$ = {:.2f} $\mu$s'.format(old_T1_val*1e6)
self.plot_dicts['text_msg_' + qbn] = {
'fig_id': base_plot_name,
'ypos': -0.2,
'xpos': 0,
'horizontalalignment': 'left',
'verticalalignment': 'top',
'plotfn': self.plot_text,
'text_string': textstr}
class RamseyAnalysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, qb_names, *args, **kwargs):
params_dict = {}
for qbn in qb_names:
s = 'Instrument settings.'+qbn
for trans_name in ['ge', 'ef']:
params_dict[f'{trans_name}_freq_'+qbn] = s+f'.{trans_name}_freq'
kwargs['params_dict'] = params_dict
kwargs['numeric_params'] = list(params_dict)
super().__init__(qb_names, *args, **kwargs)
def prepare_fitting(self):
if self.options_dict.get('fit_gaussian_decay', True):
self.fit_keys = ['exp_decay_', 'gauss_decay_']
else:
self.fit_keys = ['exp_decay_']
self.fit_dicts = OrderedDict()
for qbn in self.qb_names:
data = self.proc_data_dict['data_to_fit'][qbn]
sweep_points = self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points']
if self.num_cal_points != 0:
data = data[:-self.num_cal_points]
for i, key in enumerate([k + qbn for k in self.fit_keys]):
exp_damped_decay_mod = lmfit.Model(fit_mods.ExpDampOscFunc)
guess_pars = fit_mods.exp_damp_osc_guess(
model=exp_damped_decay_mod, data=data, t=sweep_points,
n_guess=i+1)
guess_pars['amplitude'].vary = False
guess_pars['amplitude'].value = 0.5
guess_pars['frequency'].vary = True
guess_pars['tau'].vary = True
guess_pars['phase'].vary = True
guess_pars['n'].vary = False
guess_pars['oscillation_offset'].vary = \
'f' in self.data_to_fit[qbn]
# guess_pars['exponential_offset'].value = 0.5
guess_pars['exponential_offset'].vary = True
self.set_user_guess_pars(guess_pars)
self.fit_dicts[key] = {
'fit_fn': exp_damped_decay_mod .func,
'fit_xvals': {'t': sweep_points},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
if 'artificial_detuning' in self.options_dict:
artificial_detuning_dict = OrderedDict(
[(qbn, self.options_dict['artificial_detuning'])
for qbn in self.qb_names])
elif 'artificial_detuning_dict' in self.metadata:
artificial_detuning_dict = self.metadata[
'artificial_detuning_dict']
elif 'artificial_detuning' in self.metadata:
artificial_detuning_dict = OrderedDict(
[(qbn, self.metadata['artificial_detuning'])
for qbn in self.qb_names])
else:
raise ValueError('"artificial_detuning" not found.')
self.proc_data_dict['analysis_params_dict'] = OrderedDict()
for qbn in self.qb_names:
self.proc_data_dict['analysis_params_dict'][qbn] = OrderedDict()
for key in [k + qbn for k in self.fit_keys]:
self.proc_data_dict['analysis_params_dict'][qbn][key] = \
OrderedDict()
fit_res = self.fit_dicts[key]['fit_res']
for par in fit_res.params:
if fit_res.params[par].stderr is None:
fit_res.params[par].stderr = 0
trans_name = 'ef' if 'f' in self.data_to_fit[qbn] else 'ge'
old_qb_freq = self.raw_data_dict[f'{trans_name}_freq_'+qbn]
if old_qb_freq != old_qb_freq:
old_qb_freq = 0
self.proc_data_dict['analysis_params_dict'][qbn][key][
'old_qb_freq'] = old_qb_freq
self.proc_data_dict['analysis_params_dict'][qbn][key][
'new_qb_freq'] = old_qb_freq + \
artificial_detuning_dict[qbn] - \
fit_res.best_values['frequency']
self.proc_data_dict['analysis_params_dict'][qbn][key][
'new_qb_freq_stderr'] = fit_res.params['frequency'].stderr
self.proc_data_dict['analysis_params_dict'][qbn][key][
'T2_star'] = fit_res.best_values['tau']
self.proc_data_dict['analysis_params_dict'][qbn][key][
'T2_star_stderr'] = fit_res.params['tau'].stderr
self.proc_data_dict['analysis_params_dict'][qbn][key][
'artificial_detuning'] = artificial_detuning_dict[qbn]
hdf_group_name_suffix = self.options_dict.get(
'hdf_group_name_suffix', '')
self.save_processed_data(key='analysis_params_dict' +
hdf_group_name_suffix)
def prepare_plots(self):
super().prepare_plots()
if self.do_fitting:
ramsey_dict = self.proc_data_dict['analysis_params_dict']
for qbn in self.qb_names:
base_plot_name = 'Ramsey_' + qbn
self.prepare_projected_data_plot(
fig_name=base_plot_name,
data=self.proc_data_dict['data_to_fit'][qbn],
plot_name_suffix=qbn+'fit',
qb_name=qbn)
exp_decay_fit_key = self.fit_keys[0] + qbn
old_qb_freq = ramsey_dict[qbn][
exp_decay_fit_key]['old_qb_freq']
textstr = ''
T2_star_str = ''
for i, key in enumerate([k + qbn for k in self.fit_keys]):
fit_res = self.fit_dicts[key]['fit_res']
self.plot_dicts['fit_' + key] = {
'fig_id': base_plot_name,
'plotfn': self.plot_fit,
'fit_res': fit_res,
'setlabel': 'exp decay fit' if i == 0 else
'gauss decay fit',
'do_legend': True,
'color': 'r' if i == 0 else 'C4',
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'}
if i != 0:
textstr += '\n'
textstr += \
('$f_{{qubit \_ new \_ {{{key}}} }}$ = '.format(
key=('exp' if i == 0 else 'gauss')) +
'{:.6f} GHz '.format(
ramsey_dict[qbn][key]['new_qb_freq']*1e-9) +
'$\pm$ {:.2E} GHz '.format(
ramsey_dict[qbn][key][
'new_qb_freq_stderr']*1e-9))
T2_star_str += \
('\n$T_{{2,{{{key}}} }}^\star$ = '.format(
key=('exp' if i == 0 else 'gauss')) +
'{:.2f} $\mu$s'.format(
fit_res.params['tau'].value*1e6) +
'$\pm$ {:.2f} $\mu$s'.format(
fit_res.params['tau'].stderr*1e6))
textstr += '\n$f_{qubit \_ old}$ = '+'{:.6f} GHz '.format(
old_qb_freq*1e-9)
textstr += ('\n$\Delta f$ = {:.4f} MHz '.format(
(ramsey_dict[qbn][exp_decay_fit_key]['new_qb_freq'] -
old_qb_freq)*1e-6) + '$\pm$ {:.2E} MHz'.format(
self.fit_dicts[exp_decay_fit_key]['fit_res'].params[
'frequency'].stderr*1e-6) +
'\n$f_{Ramsey}$ = '+'{:.4f} MHz $\pm$ {:.2E} MHz'.format(
self.fit_dicts[exp_decay_fit_key]['fit_res'].params[
'frequency'].value*1e-6,
self.fit_dicts[exp_decay_fit_key]['fit_res'].params[
'frequency'].stderr*1e-6))
textstr += T2_star_str
textstr += '\nartificial detuning = {:.2f} MHz'.format(
ramsey_dict[qbn][exp_decay_fit_key][
'artificial_detuning']*1e-6)
self.plot_dicts['text_msg_' + qbn] = {
'fig_id': base_plot_name,
'ypos': -0.2,
'xpos': -0.025,
'horizontalalignment': 'left',
'verticalalignment': 'top',
'plotfn': self.plot_text,
'text_string': textstr}
self.plot_dicts['half_hline_' + qbn] = {
'fig_id': base_plot_name,
'plotfn': self.plot_hlines,
'y': 0.5,
'xmin': self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'][0],
'xmax': self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'][-1],
'colors': 'gray'}
class QScaleAnalysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, qb_names, *args, **kwargs):
params_dict = {}
for qbn in qb_names:
s = 'Instrument settings.'+qbn
for trans_name in ['ge', 'ef']:
params_dict[f'{trans_name}_qscale_'+qbn] = \
s+f'.{trans_name}_motzoi'
kwargs['params_dict'] = params_dict
kwargs['numeric_params'] = list(params_dict)
super().__init__(qb_names, *args, **kwargs)
def process_data(self):
super().process_data()
self.proc_data_dict['qscale_data'] = OrderedDict()
for qbn in self.qb_names:
self.proc_data_dict['qscale_data'][qbn] = OrderedDict()
sweep_points = deepcopy(self.proc_data_dict['sweep_points_dict'][
qbn]['msmt_sweep_points'])
# check if the sweep points are repeated 3 times as they have to be
# for the qscale analysis:
# Takes the first 3 entries and check if they are all the same or different.
# Needed For backwards compatibility with QudevTransmon.measure_qscale()
# that does not (yet) use Sweeppoints object.
unique_sp = np.unique(sweep_points[:3])
if unique_sp.size > 1:
sweep_points = np.repeat(sweep_points, 3)
# replace in proc_data_dict; otherwise plotting in base class fails
self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points'] = sweep_points
self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'] = np.concatenate([
sweep_points, self.proc_data_dict['sweep_points_dict'][qbn][
'cal_points_sweep_points']])
data = self.proc_data_dict['data_to_fit'][qbn]
if self.num_cal_points != 0:
data = data[:-self.num_cal_points]
self.proc_data_dict['qscale_data'][qbn]['sweep_points_xx'] = \
sweep_points[0::3]
self.proc_data_dict['qscale_data'][qbn]['sweep_points_xy'] = \
sweep_points[1::3]
self.proc_data_dict['qscale_data'][qbn]['sweep_points_xmy'] = \
sweep_points[2::3]
self.proc_data_dict['qscale_data'][qbn]['data_xx'] = \
data[0::3]
self.proc_data_dict['qscale_data'][qbn]['data_xy'] = \
data[1::3]
self.proc_data_dict['qscale_data'][qbn]['data_xmy'] = \
data[2::3]
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
for qbn in self.qb_names:
for msmt_label in ['_xx', '_xy', '_xmy']:
sweep_points = self.proc_data_dict['qscale_data'][qbn][
'sweep_points' + msmt_label]
data = self.proc_data_dict['qscale_data'][qbn][
'data' + msmt_label]
# As a workaround for a weird bug letting crash the analysis
# every second time, we do not use lmfit.models.ConstantModel
# and lmfit.models.LinearModel, but create custom models.
if msmt_label == '_xx':
model = lmfit.Model(lambda x, c: c)
guess_pars = model.make_params(c=np.mean(data))
else:
model = lmfit.Model(lambda x, slope, intercept:
slope * x + intercept)
slope = (data[-1] - data[0]) / \
(sweep_points[-1] - sweep_points[0])
intercept = data[-1] - slope * sweep_points[-1]
guess_pars = model.make_params(slope=slope,
intercept=intercept)
self.set_user_guess_pars(guess_pars)
key = 'fit' + msmt_label + '_' + qbn
self.fit_dicts[key] = {
'fit_fn': model.func,
'fit_xvals': {'x': sweep_points},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
self.proc_data_dict['analysis_params_dict'] = OrderedDict()
# The best qscale parameter is the point where all 3 curves intersect.
threshold = 0.02
for qbn in self.qb_names:
self.proc_data_dict['analysis_params_dict'][qbn] = OrderedDict()
fitparams0 = self.fit_dicts['fit_xx'+'_'+qbn]['fit_res'].params
fitparams1 = self.fit_dicts['fit_xy'+'_'+qbn]['fit_res'].params
fitparams2 = self.fit_dicts['fit_xmy'+'_'+qbn]['fit_res'].params
intercept_diff_mean = fitparams1['intercept'].value - \
fitparams2['intercept'].value
slope_diff_mean = fitparams2['slope'].value - \
fitparams1['slope'].value
optimal_qscale = intercept_diff_mean/slope_diff_mean
# Warning if Xpi/2Xpi line is not within +/-threshold of 0.5
if (fitparams0['c'].value > (0.5 + threshold)) or \
(fitparams0['c'].value < (0.5 - threshold)):
log.warning('The trace from the X90-X180 pulses is '
'NOT within $\pm${} of the expected value '
'of 0.5.'.format(threshold))
# Warning if optimal_qscale is not within +/-threshold of 0.5
y_optimal_qscale = optimal_qscale * fitparams2['slope'].value + \
fitparams2['intercept'].value
if (y_optimal_qscale > (0.5 + threshold)) or \
(y_optimal_qscale < (0.5 - threshold)):
log.warning('The optimal qscale found gives a population '
'that is NOT within $\pm${} of the expected '
'value of 0.5.'.format(threshold))
# Calculate standard deviation
intercept_diff_std_squared = \
fitparams1['intercept'].stderr**2 + \
fitparams2['intercept'].stderr**2
slope_diff_std_squared = \
fitparams2['slope'].stderr**2 + fitparams1['slope'].stderr**2
optimal_qscale_stderr = np.sqrt(
intercept_diff_std_squared*(1/slope_diff_mean**2) +
slope_diff_std_squared*(intercept_diff_mean /
(slope_diff_mean**2))**2)
self.proc_data_dict['analysis_params_dict'][qbn]['qscale'] = \
optimal_qscale
self.proc_data_dict['analysis_params_dict'][qbn][
'qscale_stderr'] = optimal_qscale_stderr
def prepare_plots(self):
super().prepare_plots()
color_dict = {'_xx': '#365C91',
'_xy': '#683050',
'_xmy': '#3C7541'}
label_dict = {'_xx': r'$X_{\pi/2}X_{\pi}$',
'_xy': r'$X_{\pi/2}Y_{\pi}$',
'_xmy': r'$X_{\pi/2}Y_{-\pi}$'}
for qbn in self.qb_names:
base_plot_name = 'Qscale_' + qbn
for msmt_label in ['_xx', '_xy', '_xmy']:
sweep_points = self.proc_data_dict['qscale_data'][qbn][
'sweep_points' + msmt_label]
data = self.proc_data_dict['qscale_data'][qbn][
'data' + msmt_label]
if msmt_label == '_xx':
plot_name = base_plot_name
else:
plot_name = 'data' + msmt_label + '_' + qbn
xlabel, xunit = self.get_xaxis_label_unit(qbn)
self.plot_dicts[plot_name] = {
'plotfn': self.plot_line,
'xvals': sweep_points,
'xlabel': xlabel,
'xunit': xunit,
'yvals': data,
'ylabel': '{} state population'.format(
self.get_latex_prob_label(self.data_to_fit[qbn])),
'yunit': '',
'setlabel': 'Data\n' + label_dict[msmt_label],
'title': (self.raw_data_dict['timestamp'] + ' ' +
self.raw_data_dict['measurementstring'] +
'\n' + qbn),
'linestyle': 'none',
'color': color_dict[msmt_label],
'do_legend': True,
'legend_bbox_to_anchor': (1, 0.5),
'legend_pos': 'center left'}
if msmt_label != '_xx':
self.plot_dicts[plot_name]['fig_id'] = base_plot_name
if self.do_fitting:
# plot fit
xfine = np.linspace(sweep_points[0], sweep_points[-1], 1000)
fit_key = 'fit' + msmt_label + '_' + qbn
fit_res = self.fit_dicts[fit_key]['fit_res']
yvals = fit_res.model.func(xfine, **fit_res.best_values)
if not hasattr(yvals, '__iter__'):
yvals = np.array(len(xfine)*[yvals])
self.plot_dicts[fit_key] = {
'fig_id': base_plot_name,
'plotfn': self.plot_line,
'xvals': xfine,
'yvals': yvals,
'marker': '',
'setlabel': 'Fit\n' + label_dict[msmt_label],
'do_legend': True,
'color': color_dict[msmt_label],
'legend_bbox_to_anchor': (1, 0.5),
'legend_pos': 'center left'}
trans_name = 'ef' if 'f' in self.data_to_fit[qbn] else 'ge'
old_qscale_val = self.raw_data_dict[
f'{trans_name}_qscale_'+qbn]
if old_qscale_val != old_qscale_val:
old_qscale_val = 0
textstr = 'Qscale = {:.4f} $\pm$ {:.4f}'.format(
self.proc_data_dict['analysis_params_dict'][qbn][
'qscale'],
self.proc_data_dict['analysis_params_dict'][qbn][
'qscale_stderr']) + \
'\nold Qscale= {:.4f}'.format(old_qscale_val)
self.plot_dicts['text_msg_' + qbn] = {
'fig_id': base_plot_name,
'ypos': -0.175,
'xpos': 0.5,
'horizontalalignment': 'center',
'verticalalignment': 'top',
'plotfn': self.plot_text,
'text_string': textstr}
# plot cal points
if self.num_cal_points != 0:
for i, cal_pts_idxs in enumerate(
self.cal_states_dict.values()):
plot_dict_name = list(self.cal_states_dict)[i] + \
'_' + qbn
self.plot_dicts[plot_dict_name] = {
'fig_id': base_plot_name,
'plotfn': self.plot_line,
'xvals': np.mean([
self.proc_data_dict['sweep_points_dict'][qbn]
['cal_points_sweep_points'][cal_pts_idxs],
self.proc_data_dict['sweep_points_dict'][qbn]
['cal_points_sweep_points'][cal_pts_idxs]],
axis=0),
'yvals': self.proc_data_dict[
'data_to_fit'][qbn][cal_pts_idxs],
'setlabel': list(self.cal_states_dict)[i],
'do_legend': True,
'legend_bbox_to_anchor': (1, 0.5),
'legend_pos': 'center left',
'linestyle': 'none',
'line_kws': {'color': self.get_cal_state_color(
list(self.cal_states_dict)[i])}}
self.plot_dicts[plot_dict_name + '_line'] = {
'fig_id': base_plot_name,
'plotfn': self.plot_hlines,
'y': np.mean(
self.proc_data_dict[
'data_to_fit'][qbn][cal_pts_idxs]),
'xmin': self.proc_data_dict['sweep_points_dict'][
qbn]['sweep_points'][0],
'xmax': self.proc_data_dict['sweep_points_dict'][
qbn]['sweep_points'][-1],
'colors': 'gray'}
class EchoAnalysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, *args, **kwargs):
auto = kwargs.pop('auto', True)
super().__init__(*args, auto=False, **kwargs)
if self.options_dict.get('artificial_detuning', None) is not None:
self.echo_analysis = RamseyAnalysis(*args, auto=False, **kwargs)
else:
if 'options_dict' in kwargs:
# kwargs.pop('options_dict')
kwargs['options_dict'].update({'vary_offset': True})
else:
kwargs['options_dict'] = {'vary_offset': True}
self.echo_analysis = T1Analysis(*args, auto=False, **kwargs)
if auto:
self.echo_analysis.extract_data()
self.echo_analysis.process_data()
self.echo_analysis.prepare_fitting()
self.echo_analysis.run_fitting()
self.echo_analysis.save_fit_results()
self.analyze_fit_results()
self.prepare_plots()
def analyze_fit_results(self):
self.echo_analysis.analyze_fit_results()
self.proc_data_dict['analysis_params_dict'] = OrderedDict()
for qbn in self.qb_names:
self.proc_data_dict['analysis_params_dict'][qbn] = OrderedDict()
params_dict = self.echo_analysis.proc_data_dict[
'analysis_params_dict'][qbn]
if 'T1' in params_dict:
self.proc_data_dict['analysis_params_dict'][qbn][
'T2_echo'] = params_dict['T1']
self.proc_data_dict['analysis_params_dict'][qbn][
'T2_echo_stderr'] = params_dict['T1_stderr']
else:
self.proc_data_dict['analysis_params_dict'][qbn][
'T2_echo'] = params_dict['exp_decay_'+qbn][
'T2_star']
self.proc_data_dict['analysis_params_dict'][qbn][
'T2_echo_stderr'] = params_dict['exp_decay_'+qbn][
'T2_star_stderr']
def prepare_plots(self):
self.echo_analysis.prepare_plots()
for qbn in self.qb_names:
# rename base plot
figure_name = 'Echo_' + qbn
echo_plot_key_t1 = [key for key in self.echo_analysis.plot_dicts if
'T1_'+qbn in key]
echo_plot_key_ram = [key for key in self.echo_analysis.plot_dicts if
'Ramsey_'+qbn in key]
if len(echo_plot_key_t1) != 0:
echo_plot_name = echo_plot_key_t1[0]
elif len(echo_plot_key_ram) != 0:
echo_plot_name = echo_plot_key_ram[0]
else:
raise ValueError('Neither T1 nor Ramsey plots were found.')
self.echo_analysis.plot_dicts[echo_plot_name][
'legend_pos'] = 'upper right'
self.echo_analysis.plot_dicts[echo_plot_name][
'legend_bbox_to_anchor'] = (1, -0.15)
for plot_label in self.echo_analysis.plot_dicts:
if qbn in plot_label:
if 'raw' not in plot_label and 'projected' not in plot_label:
self.echo_analysis.plot_dicts[plot_label]['fig_id'] = \
figure_name
old_T2e_val = a_tools.get_instr_setting_value_from_file(
file_path=self.echo_analysis.raw_data_dict['folder'],
instr_name=qbn, param_name='T2{}'.format(
'_ef' if 'f' in self.echo_analysis.data_to_fit[qbn]
else ''))
T2_dict = self.proc_data_dict['analysis_params_dict']
textstr = '$T_2$ echo = {:.2f} $\mu$s'.format(
T2_dict[qbn]['T2_echo']*1e6) \
+ ' $\pm$ {:.2f} $\mu$s'.format(
T2_dict[qbn]['T2_echo_stderr']*1e6) \
+ '\nold $T_2$ echo = {:.2f} $\mu$s'.format(
old_T2e_val*1e6)
self.echo_analysis.plot_dicts['text_msg_' + qbn][
'text_string'] = textstr
self.echo_analysis.plot(key_list='auto')
self.echo_analysis.save_figures(close_figs=True)
class RamseyAddPulseAnalysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, *args, **kwargs):
auto = kwargs.pop('auto', True)
super().__init__(*args, auto=False, **kwargs)
options_dict = kwargs.pop('options_dict', OrderedDict())
options_dict_no = deepcopy(options_dict)
options_dict_no.update(dict(
data_filter=lambda raw: np.concatenate([
raw[:-4][1::2], raw[-4:]]),
hdf_group_name_suffix='_no_pulse'))
self.ramsey_analysis = RamseyAnalysis(
*args, auto=False, options_dict=options_dict_no,
**kwargs)
options_dict_with = deepcopy(options_dict)
options_dict_with.update(dict(
data_filter=lambda raw: np.concatenate([
raw[:-4][0::2], raw[-4:]]),
hdf_group_name_suffix='_with_pulse'))
self.ramsey_add_pulse_analysis = RamseyAnalysis(
*args, auto=False, options_dict=options_dict_with,
**kwargs)
if auto:
self.ramsey_analysis.extract_data()
self.ramsey_analysis.process_data()
self.ramsey_analysis.prepare_fitting()
self.ramsey_analysis.run_fitting()
self.ramsey_analysis.save_fit_results()
self.ramsey_add_pulse_analysis.extract_data()
self.ramsey_add_pulse_analysis.process_data()
self.ramsey_add_pulse_analysis.prepare_fitting()
self.ramsey_add_pulse_analysis.run_fitting()
self.ramsey_add_pulse_analysis.save_fit_results()
self.raw_data_dict = self.ramsey_analysis.raw_data_dict
self.analyze_fit_results()
self.prepare_plots()
keylist = []
for qbn in self.qb_names:
figure_name = 'CrossZZ_' + qbn
keylist.append(figure_name+'with')
keylist.append(figure_name+'no')
self.plot()
self.save_figures(close_figs=True)
def analyze_fit_results(self):
self.cross_kerr = 0.0
self.ramsey_analysis.analyze_fit_results()
self.ramsey_add_pulse_analysis.analyze_fit_results()
self.proc_data_dict['analysis_params_dict'] = OrderedDict()
for qbn in self.qb_names:
self.proc_data_dict['analysis_params_dict'][qbn] = OrderedDict()
self.params_dict_ramsey = self.ramsey_analysis.proc_data_dict[
'analysis_params_dict'][qbn]
self.params_dict_add_pulse = \
self.ramsey_add_pulse_analysis.proc_data_dict[
'analysis_params_dict'][qbn]
self.cross_kerr = self.params_dict_ramsey[
'exp_decay_'+str(qbn)]['new_qb_freq'] \
- self.params_dict_add_pulse[
'exp_decay_'+str(qbn)]['new_qb_freq']
self.cross_kerr_error = np.sqrt(
(self.params_dict_ramsey[
'exp_decay_'+str(qbn)]['new_qb_freq_stderr'])**2 +
(self.params_dict_add_pulse[
'exp_decay_' + str(qbn)]['new_qb_freq_stderr'])**2)
def prepare_plots(self):
self.ramsey_analysis.prepare_plots()
self.ramsey_add_pulse_analysis.prepare_plots()
self.ramsey_analysis.plot(key_list='auto')
self.ramsey_analysis.save_figures(close_figs=True, savebase='Ramsey_no')
self.ramsey_add_pulse_analysis.plot(key_list='auto')
self.ramsey_add_pulse_analysis.save_figures(close_figs=True,
savebase='Ramsey_with')
self.options_dict['plot_proj_data'] = False
self.metadata = {'plot_proj_data': False, 'plot_raw_data': False}
super().prepare_plots()
try:
xunit = self.metadata["sweep_unit"]
xlabel = self.metadata["sweep_name"]
except KeyError:
xlabel = self.raw_data_dict['sweep_parameter_names'][0]
xunit = self.raw_data_dict['sweep_parameter_units'][0]
if np.ndim(xunit) > 0:
xunit = xunit[0]
title = (self.raw_data_dict['timestamp'] + ' ' +
self.raw_data_dict['measurementstring'])
for qbn in self.qb_names:
data_no = self.ramsey_analysis.proc_data_dict['data_to_fit'][
qbn][:-self.ramsey_analysis.num_cal_points]
data_with = self.ramsey_add_pulse_analysis.proc_data_dict[
'data_to_fit'][
qbn][:-self.ramsey_analysis.num_cal_points]
delays = self.ramsey_analysis.proc_data_dict['sweep_points_dict'][
qbn]['sweep_points'][
:-self.ramsey_analysis.num_cal_points]
figure_name = 'CrossZZ_' + qbn
self.plot_dicts[figure_name+'with'] = {
'fig_id': figure_name,
'plotfn': self.plot_line,
'xvals': delays,
'yvals': data_with,
'xlabel': xlabel,
'xunit': xunit,
'ylabel': '|e> state population',
'setlabel': 'with $\\pi$-pulse',
'title': title,
'color': 'r',
'marker': 'o',
'line_kws': {'markersize': 5},
'linestyle': 'none',
'do_legend': True,
'legend_ncol': 2,
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'}
if self.do_fitting:
fit_res_with = self.ramsey_add_pulse_analysis.fit_dicts[
'exp_decay_' + qbn]['fit_res']
self.plot_dicts['fit_with_'+qbn] = {
'fig_id': figure_name,
'plotfn': self.plot_fit,
'xlabel': 'Ramsey delay',
'xunit': 's',
'fit_res': fit_res_with,
'setlabel': 'with $\\pi$-pulse - fit',
'title': title,
'do_legend': True,
'color': 'r',
'legend_ncol': 2,
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'}
self.plot_dicts[figure_name+'no'] = {
'fig_id': figure_name,
'plotfn': self.plot_line,
'xvals': delays,
'yvals': data_no,
'setlabel': 'no $\\pi$-pulse',
'title': title,
'color': 'g',
'marker': 'o',
'line_kws': {'markersize': 5},
'linestyle': 'none',
'do_legend': True,
'legend_ncol': 2,
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'}
if self.do_fitting:
fit_res_no = self.ramsey_analysis.fit_dicts[
'exp_decay_' + qbn]['fit_res']
self.plot_dicts['fit_no_'+qbn] = {
'fig_id': figure_name,
'plotfn': self.plot_fit,
'xlabel': 'Ramsey delay',
'xunit': 's',
'fit_res': fit_res_no,
'setlabel': 'no $\\pi$-pulse - fit',
'title': title,
'do_legend': True,
'color': 'g',
'legend_ncol': 2,
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'}
textstr = r'$\alpha ZZ$ = {:.2f} +- {:.2f}'.format(
self.cross_kerr*1e-3, self.cross_kerr_error*1e-3) + ' kHz'
self.plot_dicts['text_msg_' + qbn] = {'fig_id': figure_name,
'text_string': textstr,
'ypos': -0.2,
'xpos': -0.075,
'horizontalalignment': 'left',
'verticalalignment': 'top',
'plotfn': self.plot_text}
class OverUnderRotationAnalysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
for qbn in self.qb_names:
data = self.proc_data_dict['projected_data_dict'][qbn]
sweep_points = self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points']
if self.num_cal_points != 0:
data = data[:-self.num_cal_points]
model = lmfit.models.LinearModel()
guess_pars = model.guess(data=data, x=sweep_points)
guess_pars['intercept'].value = 0.5
guess_pars['intercept'].vary = False
key = 'fit_' + qbn
self.fit_dicts[key] = {
'fit_fn': model.func,
'fit_xvals': {'x': sweep_points},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
self.proc_data_dict['analysis_params_dict'] = OrderedDict()
for qbn in self.qb_names:
try:
old_amp180 = a_tools.get_instr_setting_value_from_file(
file_path=self.raw_data_dict['folder'][0],
instr_name=qbn, param_name='amp180{}'.format(
'_ef' if 'f' in self.data_to_fit[qbn] else ''))
except KeyError:
old_amp180 = a_tools.get_instr_setting_value_from_file(
file_path=self.raw_data_dict['folder'][0],
instr_name=qbn, param_name='{}_amp180'.format(
'ef' if 'f' in self.data_to_fit[qbn] else 'ge'))
self.proc_data_dict['analysis_params_dict'][qbn] = OrderedDict()
self.proc_data_dict['analysis_params_dict'][qbn][
'corrected_amp'] = old_amp180 - self.fit_dicts[
'fit_' + qbn]['fit_res'].best_values['slope']*old_amp180
self.proc_data_dict['analysis_params_dict'][qbn][
'corrected_amp_stderr'] = self.fit_dicts[
'fit_' + qbn]['fit_res'].params['slope'].stderr*old_amp180
def prepare_plots(self):
super().prepare_plots()
if self.do_fitting:
for qbn in self.qb_names:
# rename base plot
if self.fit_dicts['fit_' + qbn][
'fit_res'].best_values['slope'] >= 0:
base_plot_name = 'OverRotation_' + qbn
else:
base_plot_name = 'UnderRotation_' + qbn
self.prepare_projected_data_plot(
fig_name=base_plot_name,
data=self.proc_data_dict['data_to_fit'][qbn],
plot_name_suffix=qbn+'fit',
qb_name=qbn)
self.plot_dicts['fit_' + qbn] = {
'fig_id': base_plot_name,
'plotfn': self.plot_fit,
'fit_res': self.fit_dicts['fit_' + qbn]['fit_res'],
'setlabel': 'linear fit',
'do_legend': True,
'color': 'r',
'legend_ncol': 2,
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'}
try:
old_amp180 = a_tools.get_instr_setting_value_from_file(
file_path=self.raw_data_dict['folder'][0],
instr_name=qbn, param_name='amp180{}'.format(
'_ef' if 'f' in self.data_to_fit[qbn] else ''))
except KeyError:
old_amp180 = a_tools.get_instr_setting_value_from_file(
file_path=self.raw_data_dict['folder'][0],
instr_name=qbn, param_name='{}_amp180'.format(
'ef' if 'f' in self.data_to_fit[qbn] else 'ge'))
correction_dict = self.proc_data_dict['analysis_params_dict']
fit_res = self.fit_dicts['fit_' + qbn]['fit_res']
textstr = '$\pi$-Amp = {:.4f} mV'.format(
correction_dict[qbn]['corrected_amp']*1e3) \
+ ' $\pm$ {:.1e} mV'.format(
correction_dict[qbn]['corrected_amp_stderr']*1e3) \
+ '\nold $\pi$-Amp = {:.4f} mV'.format(
old_amp180*1e3) \
+ '\namp. correction = {:.4f} mV'.format(
fit_res.best_values['slope']*old_amp180*1e3) \
+ '\nintercept = {:.2f}'.format(
fit_res.best_values['intercept'])
self.plot_dicts['text_msg_' + qbn] = {
'fig_id': base_plot_name,
'ypos': -0.2,
'xpos': 0,
'horizontalalignment': 'left',
'verticalalignment': 'top',
'plotfn': self.plot_text,
'text_string': textstr}
self.plot_dicts['half_hline_' + qbn] = {
'fig_id': base_plot_name,
'plotfn': self.plot_hlines,
'y': 0.5,
'xmin': self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'][0],
'xmax': self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points'][-1],
'colors': 'gray'}
class MultiCZgate_Calib_Analysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, *args, **kwargs):
options_dict = kwargs.pop('options_dict', {})
options_dict.update({'TwoD': True})
kwargs.update({'options_dict': options_dict})
self.phase_key = 'phase_diffs'
self.legend_label_func = lambda qbn, row: ''
super().__init__(*args, **kwargs)
def process_data(self):
super().process_data()
# Find leakage and ramsey qubit names
self.leakage_qbnames = self.get_param_value('leakage_qbnames',
default_value=[])
self.ramsey_qbnames = self.get_param_value('ramsey_qbnames',
default_value=[])
self.gates_list = self.get_param_value('gates_list', default_value=[])
if not len(self.gates_list):
leakage_qbnames_temp = len(self.ramsey_qbnames) * ['']
self.gates_list = [(qbl, qbr) for qbl, qbr in
zip(leakage_qbnames_temp, self.ramsey_qbnames)]
# TODO: Steph 15.09.2020
# This is a hack. It should be done in MultiQubit_TimeDomain_Analysis
# but would break every analysis inheriting from it but we just needed
# it to work for this analysis :)
self.data_to_fit = self.get_param_value('data_to_fit', {})
for qbn in self.data_to_fit:
# make values of data_to_fit be lists
if isinstance(self.data_to_fit[qbn], str):
self.data_to_fit[qbn] = [self.data_to_fit[qbn]]
# Overwrite data_to_fit in proc_data_dict
self.proc_data_dict['data_to_fit'] = OrderedDict()
for qbn, prob_data in self.proc_data_dict[
'projected_data_dict'].items():
if qbn in self.data_to_fit:
self.proc_data_dict['data_to_fit'][qbn] = {
prob_label: prob_data[prob_label] for prob_label in
self.data_to_fit[qbn]}
# Make sure data has the right shape (len(hard_sp), len(soft_sp))
for qbn, prob_data in self.proc_data_dict['data_to_fit'].items():
for prob_label, data in prob_data.items():
if data.shape[1] != self.proc_data_dict[
'sweep_points_dict'][qbn]['sweep_points'].size:
self.proc_data_dict['data_to_fit'][qbn][prob_label] = data.T
# reshape data for ease of use
qbn = self.qb_names[0]
phase_sp_param_name = [p for p in self.mospm[qbn] if 'phase' in p][0]
phases = self.sp.get_sweep_params_property('values', 0,
phase_sp_param_name)
self.dim_scale_factor = len(phases) // len(np.unique(phases))
self.proc_data_dict['data_to_fit_reshaped'] = OrderedDict()
for qbn in self.qb_names:
self.proc_data_dict['data_to_fit_reshaped'][qbn] = {
prob_label: np.reshape(
self.proc_data_dict['data_to_fit'][qbn][prob_label][
:, :-self.num_cal_points],
(self.dim_scale_factor * \
self.proc_data_dict['data_to_fit'][qbn][prob_label][
:, :-self.num_cal_points].shape[0],
self.proc_data_dict['data_to_fit'][qbn][prob_label][
:, :-self.num_cal_points].shape[1]//self.dim_scale_factor))
for prob_label in self.proc_data_dict['data_to_fit'][qbn]}
# convert phases to radians
for qbn in self.qb_names:
sweep_dict = self.proc_data_dict['sweep_points_dict'][qbn]
sweep_dict['sweep_points'] *= np.pi/180
def plot_traces(self, prob_label, data_2d, qbn):
plotsize = self.get_default_plot_params(set=False)[
'figure.figsize']
plotsize = (plotsize[0], plotsize[0]/1.25)
if data_2d.shape[1] != self.proc_data_dict[
'sweep_points_dict'][qbn]['sweep_points'].size:
data_2d = data_2d.T
data_2d_reshaped = np.reshape(
data_2d[:, :-self.num_cal_points],
(self.dim_scale_factor*data_2d[:, :-self.num_cal_points].shape[0],
data_2d[:, :-self.num_cal_points].shape[1]//self.dim_scale_factor))
data_2d_cal_reshaped = [[data_2d[:, -self.num_cal_points:]]] * \
(self.dim_scale_factor *
data_2d[:, :-self.num_cal_points].shape[0])
ref_states_plot_dicts = {}
for row in range(data_2d_reshaped.shape[0]):
phases = np.unique(self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points'])
data = data_2d_reshaped[row, :]
legend_bbox_to_anchor = (1, -0.15)
legend_pos = 'upper right'
legend_ncol = 2
if qbn in self.ramsey_qbnames and self.get_latex_prob_label(
prob_label) in [self.get_latex_prob_label(pl)
for pl in self.data_to_fit[qbn]]:
figure_name = '{}_{}_{}'.format(self.phase_key, qbn, prob_label)
elif qbn in self.leakage_qbnames and self.get_latex_prob_label(
prob_label) in [self.get_latex_prob_label(pl)
for pl in self.data_to_fit[qbn]]:
figure_name = 'Leakage_{}_{}'.format(qbn, prob_label)
else:
figure_name = 'projected_plot_' + qbn + '_' + \
prob_label
# plot cal points
if self.num_cal_points > 0:
data_w_cal = data_2d_cal_reshaped[row][0][0]
for i, cal_pts_idxs in enumerate(
self.cal_states_dict.values()):
s = '{}_{}_{}'.format(row, qbn, prob_label)
ref_state_plot_name = list(
self.cal_states_dict)[i] + '_' + s
ref_states_plot_dicts[ref_state_plot_name] = {
'fig_id': figure_name,
'plotfn': self.plot_line,
'plotsize': plotsize,
'xvals': self.proc_data_dict[
'sweep_points_dict'][qbn][
'cal_points_sweep_points'][
cal_pts_idxs],
'yvals': data_w_cal[cal_pts_idxs],
'setlabel': list(
self.cal_states_dict)[i] if
row == 0 else '',
'do_legend': row == 0,
'legend_bbox_to_anchor':
legend_bbox_to_anchor,
'legend_pos': legend_pos,
'legend_ncol': legend_ncol,
'linestyle': 'none',
'line_kws': {'color':
self.get_cal_state_color(
list(self.cal_states_dict)[i])}}
xlabel, xunit = self.get_xaxis_label_unit(qbn)
self.plot_dicts['data_{}_{}_{}'.format(
row, qbn, prob_label)] = {
'plotfn': self.plot_line,
'fig_id': figure_name,
'plotsize': plotsize,
'xvals': phases,
'xlabel': xlabel,
'xunit': xunit,
'yvals': data,
'ylabel': '{} state population'.format(
self.get_latex_prob_label(prob_label)),
'yunit': '',
'yscale': self.get_param_value("yscale", "linear"),
'setlabel': 'Data - ' + self.legend_label_func(qbn, row)
if row in [0, 1] else '',
'title': self.raw_data_dict['timestamp'] + ' ' +
self.raw_data_dict['measurementstring'] + '-' + qbn,
'linestyle': 'none',
'color': 'C0' if row % 2 == 0 else 'C2',
'do_legend': row in [0, 1],
'legend_ncol': legend_ncol,
'legend_bbox_to_anchor': legend_bbox_to_anchor,
'legend_pos': legend_pos}
if self.do_fitting and 'projected' not in figure_name:
if qbn in self.leakage_qbnames and self.get_param_value(
'classified_ro', False):
continue
k = 'fit_{}{}_{}_{}'.format(
'on' if row % 2 == 0 else 'off', row, prob_label, qbn)
if f'Cos_{k}' in self.fit_dicts:
fit_res = self.fit_dicts[f'Cos_{k}']['fit_res']
self.plot_dicts[k + '_' + prob_label] = {
'fig_id': figure_name,
'plotfn': self.plot_fit,
'fit_res': fit_res,
'setlabel': 'Fit - ' + self.legend_label_func(qbn, row)
if row in [0, 1] else '',
'color': 'C0' if row % 2 == 0 else 'C2',
'do_legend': row in [0, 1],
'legend_ncol': legend_ncol,
'legend_bbox_to_anchor':
legend_bbox_to_anchor,
'legend_pos': legend_pos}
elif f'Linear_{k}' in self.fit_dicts:
fit_res = self.fit_dicts[f'Linear_{k}']['fit_res']
xvals = fit_res.userkws[
fit_res.model.independent_vars[0]]
xfine = np.linspace(min(xvals), max(xvals), 100)
yvals = fit_res.model.func(
xfine, **fit_res.best_values)
if not hasattr(yvals, '__iter__'):
yvals = np.array(len(xfine)*[yvals])
self.plot_dicts[k] = {
'fig_id': figure_name,
'plotfn': self.plot_line,
'xvals': xfine,
'yvals': yvals,
'marker': '',
'setlabel': 'Fit - ' + self.legend_label_func(
qbn, row) if row in [0, 1] else '',
'do_legend': row in [0, 1],
'legend_ncol': legend_ncol,
'color': 'C0' if row % 2 == 0 else 'C2',
'legend_bbox_to_anchor':
legend_bbox_to_anchor,
'legend_pos': legend_pos}
# ref state plots need to be added at the end, otherwise the
# legend for |g> and |e> is added twice (because of the
# condition do_legend = (row in [0,1]) in the plot dicts above
if self.num_cal_points > 0:
self.plot_dicts.update(ref_states_plot_dicts)
return figure_name
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
self.leakage_values = np.array([])
labels = ['on', 'off']
for i, qbn in enumerate(self.qb_names):
for prob_label in self.data_to_fit[qbn]:
for row in range(self.proc_data_dict['data_to_fit_reshaped'][
qbn][prob_label].shape[0]):
phases = np.unique(self.proc_data_dict['sweep_points_dict'][
qbn]['msmt_sweep_points'])
data = self.proc_data_dict['data_to_fit_reshaped'][qbn][
prob_label][row, :]
key = 'fit_{}{}_{}_{}'.format(labels[row % 2], row,
prob_label, qbn)
if qbn in self.leakage_qbnames and prob_label == 'pf':
if self.get_param_value('classified_ro', False):
self.leakage_values = np.append(self.leakage_values,
np.mean(data))
else:
# fit leakage qb results to a constant
model = lmfit.models.ConstantModel()
guess_pars = model.guess(data=data, x=phases)
self.fit_dicts[f'Linear_{key}'] = {
'fit_fn': model.func,
'fit_xvals': {'x': phases},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
elif prob_label == 'pe' or prob_label == 'pg':
# fit ramsey qb results to a cosine
model = lmfit.Model(fit_mods.CosFunc)
guess_pars = fit_mods.Cos_guess(
model=model,
t=phases,
data=data, freq_guess=1/(2*np.pi))
guess_pars['frequency'].value = 1/(2*np.pi)
guess_pars['frequency'].vary = False
self.fit_dicts[f'Cos_{key}'] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': phases},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
self.proc_data_dict['analysis_params_dict'] = OrderedDict()
for qbn in self.qb_names:
# Cos fits
keys = [k for k in list(self.fit_dicts.keys()) if
(k.startswith('Cos') and k.endswith(qbn))]
if len(keys) > 0:
fit_res_objs = [self.fit_dicts[k]['fit_res'] for k in keys]
# cosine amplitudes
amps = np.array([fr.best_values['amplitude'] for fr
in fit_res_objs])
amps_errs = np.array([fr.params['amplitude'].stderr
for fr in fit_res_objs], dtype=np.float64)
amps_errs = np.nan_to_num(amps_errs)
# amps_errs.dtype = amps.dtype
if qbn in self.ramsey_qbnames:
# phase_diffs
phases = np.array([fr.best_values['phase'] for fr in
fit_res_objs])
phases_errs = np.array([fr.params['phase'].stderr for fr in
fit_res_objs], dtype=np.float64)
phases_errs = np.nan_to_num(phases_errs)
self.proc_data_dict['analysis_params_dict'][
f'phases_{qbn}'] = {
'val': phases, 'stderr': phases_errs}
# compute phase diffs
if getattr(self, 'delta_tau', 0) is not None:
# this can be false for Cyroscope with
# estimation_window == None and odd nr of trunc lengths
phase_diffs = phases[0::2] - phases[1::2]
phase_diffs %= (2*np.pi)
phase_diffs_stderrs = np.sqrt(
np.array(phases_errs[0::2]**2 +
phases_errs[1::2]**2, dtype=np.float64))
self.proc_data_dict['analysis_params_dict'][
f'{self.phase_key}_{qbn}'] = {
'val': phase_diffs, 'stderr': phase_diffs_stderrs}
# population_loss = (cos_amp_g - cos_amp_e)/ cos_amp_g
population_loss = (amps[1::2] - amps[0::2])/amps[1::2]
x = amps[1::2] - amps[0::2]
x_err = np.array(amps_errs[0::2]**2 + amps_errs[1::2]**2,
dtype=np.float64)
y = amps[1::2]
y_err = amps_errs[1::2]
try:
population_loss_stderrs = np.sqrt(np.array(
((y * x_err) ** 2 + (x * y_err) ** 2) / (y ** 4),
dtype=np.float64))
except:
population_loss_stderrs = float("nan")
self.proc_data_dict['analysis_params_dict'][
f'population_loss_{qbn}'] = \
{'val': population_loss,
'stderr': population_loss_stderrs}
else:
self.proc_data_dict['analysis_params_dict'][
f'amps_{qbn}'] = {
'val': amps[1::2], 'stderr': amps_errs[1::2]}
# Linear fits
keys = [k for k in list(self.fit_dicts.keys()) if
(k.startswith('Linear') and k.endswith(qbn))]
if len(keys) > 0:
fit_res_objs = [self.fit_dicts[k]['fit_res'] for k in keys]
# get leakage
lines = np.array([fr.best_values['c'] for fr
in fit_res_objs])
lines_errs = np.array([fr.params['c'].stderr for
fr in fit_res_objs], dtype=np.float64)
lines_errs = np.nan_to_num(lines_errs)
leakage = lines[0::2]
leakage_errs = np.array(lines_errs[0::2], dtype=np.float64)
leakage_increase = lines[0::2] - lines[1::2]
leakage_increase_errs = np.array(np.sqrt(lines_errs[0::2]**2,
lines_errs[1::2]**2),
dtype=np.float64)
self.proc_data_dict['analysis_params_dict'][
f'leakage_{qbn}'] = \
{'val': leakage, 'stderr': leakage_errs}
self.proc_data_dict['analysis_params_dict'][
f'leakage_increase_{qbn}'] = {'val': leakage_increase,
'stderr': leakage_increase_errs}
# special case: if classified detector was used, we get leakage
# for free
if qbn in self.leakage_qbnames and self.get_param_value(
'classified_ro', False):
leakage = self.leakage_values[0::2]
leakage_errs = np.zeros(len(leakage))
leakage_increase = self.leakage_values[0::2] - \
self.leakage_values[1::2]
leakage_increase_errs = np.zeros(len(leakage))
self.proc_data_dict['analysis_params_dict'][
f'leakage_{qbn}'] = \
{'val': leakage, 'stderr': leakage_errs}
self.proc_data_dict['analysis_params_dict'][
f'leakage_increase_{qbn}'] = {'val': leakage_increase,
'stderr': leakage_increase_errs}
self.save_processed_data(key='analysis_params_dict')
def prepare_plots(self):
len_ssp = len(self.proc_data_dict['analysis_params_dict'][
f'{self.phase_key}_{self.ramsey_qbnames[0]}']['val'])
if self.options_dict.get('plot_all_traces', True):
for j, qbn in enumerate(self.qb_names):
if self.options_dict.get('plot_all_probs', True):
for prob_label, data_2d in self.proc_data_dict[
'projected_data_dict'][qbn].items():
figure_name = self.plot_traces(prob_label, data_2d, qbn)
else:
for prob_label, data_2d in self.proc_data_dict[
'data_to_fit'][qbn]:
figure_name = self.plot_traces(prob_label, data_2d, qbn)
if self.do_fitting and len_ssp == 1:
self.options_dict.update({'TwoD': False,
'plot_proj_data': False})
super().prepare_plots()
if qbn in self.ramsey_qbnames:
# add the cphase + leakage textboxes to the
# cphase_qbr_pe figure
figure_name = f'{self.phase_key}_{qbn}_pe'
textstr = '{} = \n{:.2f}'.format(
self.phase_key,
self.proc_data_dict['analysis_params_dict'][
f'{self.phase_key}_{qbn}']['val'][0]*180/np.pi) + \
r'$^{\circ}$' + \
'$\\pm${:.2f}'.format(
self.proc_data_dict[
'analysis_params_dict'][
f'{self.phase_key}_{qbn}'][
'stderr'][0] * 180 / np.pi) + \
r'$^{\circ}$'
textstr += '\n\nContrast loss = \n' + \
'{:.3f} $\\pm$ {:.3f}'.format(
self.proc_data_dict[
'analysis_params_dict'][
f'population_loss_{qbn}']['val'][0],
self.proc_data_dict[
'analysis_params_dict'][
f'population_loss_{qbn}'][
'stderr'][0])
self.plot_dicts['cphase_text_msg_' + qbn] = {
'fig_id': figure_name,
'ypos': -0.2,
'xpos': -0.1,
'horizontalalignment': 'left',
'verticalalignment': 'top',
'box_props': None,
'plotfn': self.plot_text,
'text_string': textstr}
qbl = [gl[0] for gl in self.gates_list
if qbn == gl[1]]
if len(qbl):
qbl = qbl[0]
textstr = 'Leakage =\n{:.5f} $\\pm$ {:.5f}'.format(
self.proc_data_dict['analysis_params_dict'][
f'leakage_{qbl}']['val'][0],
self.proc_data_dict['analysis_params_dict'][
f'leakage_{qbl}']['stderr'][0])
textstr += '\n\n$\\Delta$Leakage = \n' \
'{:.5f} $\\pm$ {:.5f}'.format(
self.proc_data_dict['analysis_params_dict'][
f'leakage_increase_{qbl}']['val'][0],
self.proc_data_dict['analysis_params_dict'][
f'leakage_increase_{qbl}']['stderr'][0])
self.plot_dicts['cphase_text_msg_' + qbl] = {
'fig_id': figure_name,
'ypos': -0.2,
'xpos': 0.175,
'horizontalalignment': 'left',
'verticalalignment': 'top',
'box_props': None,
'plotfn': self.plot_text,
'text_string': textstr}
else:
if f'amps_{qbn}' in self.proc_data_dict[
'analysis_params_dict']:
figure_name = f'Leakage_{qbn}_pg'
textstr = 'Amplitude CZ int. OFF = \n' + \
'{:.3f} $\\pm$ {:.3f}'.format(
self.proc_data_dict[
'analysis_params_dict'][
f'amps_{qbn}']['val'][0],
self.proc_data_dict[
'analysis_params_dict'][
f'amps_{qbn}']['stderr'][0])
self.plot_dicts['swap_text_msg_' + qbn] = {
'fig_id': figure_name,
'ypos': -0.2,
'xpos': -0.1,
'horizontalalignment': 'left',
'verticalalignment': 'top',
'box_props': None,
'plotfn': self.plot_text,
'text_string': textstr}
# plot analysis results
if self.do_fitting and len_ssp > 1:
for qbn in self.qb_names:
ss_pars = self.proc_data_dict['sweep_points_2D_dict'][qbn]
for idx, ss_pname in enumerate(ss_pars):
xvals = self.sp.get_sweep_params_property('values', 1,
ss_pname)
xvals_to_use = deepcopy(xvals)
xlabel = self.sp.get_sweep_params_property('label', 1,
ss_pname)
xunit = self.sp.get_sweep_params_property('unit', 1,
ss_pname)
for param_name, results_dict in self.proc_data_dict[
'analysis_params_dict'].items():
if qbn in param_name:
reps = 1
if len(results_dict['val']) >= len(xvals):
reps = len(results_dict['val']) / len(xvals)
else:
# cyroscope case
if hasattr(self, 'xvals_reduction_func'):
xvals_to_use = self.xvals_reduction_func(
xvals)
else:
log.warning(f'Length mismatch between xvals'
' and analysis param for'
' {param_name}, and no'
' xvals_reduction_func has been'
' defined. Unclear how to'
' reduce xvals.')
plot_name = f'{param_name}_vs_{xlabel}'
if 'phase' in param_name:
yvals = results_dict['val']*180/np.pi - (180 if
len(self.leakage_qbnames) > 0 else 0)
yerr = results_dict['stderr']*180/np.pi
ylabel = param_name + ('-$180^{\\circ}$' if
len(self.leakage_qbnames) > 0 else '')
self.plot_dicts[plot_name+'_hline'] = {
'fig_id': plot_name,
'plotfn': self.plot_hlines,
'y': 0,
'xmin': np.min(xvals_to_use),
'xmax': np.max(xvals_to_use),
'colors': 'gray'}
else:
yvals = results_dict['val']
yerr = results_dict['stderr']
ylabel = param_name
if 'phase' in param_name:
yunit = 'deg'
elif 'freq' in param_name:
yunit = 'Hz'
else:
yunit = ''
self.plot_dicts[plot_name] = {
'plotfn': self.plot_line,
'xvals': np.repeat(xvals_to_use, reps),
'xlabel': xlabel,
'xunit': xunit,
'yvals': yvals,
'yerr': yerr if param_name != 'leakage'
else None,
'ylabel': ylabel,
'yunit': yunit,
'title': self.raw_data_dict['timestamp'] + ' ' +
self.raw_data_dict['measurementstring']
+ '-' + qbn,
'linestyle': 'none',
'do_legend': False}
class CPhaseLeakageAnalysis(MultiCZgate_Calib_Analysis):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def process_data(self):
super().process_data()
# Find leakage and ramsey qubit names
# first try the legacy code
leakage_qbname = self.get_param_value('leakage_qbname')
ramsey_qbname = self.get_param_value('ramsey_qbname')
if leakage_qbname is not None and ramsey_qbname is not None:
self.gates_list += [(leakage_qbname, ramsey_qbname)]
self.leakage_qbnames = [leakage_qbname]
self.ramsey_qbnames = [ramsey_qbname]
else:
# new measurement framework
task_list = self.get_param_value('task_list', default_value=[])
for task in task_list:
self.gates_list += [(task['qbl'], task['qbr'])]
self.leakage_qbnames += [task['qbl']]
self.ramsey_qbnames += [task['qbr']]
if len(self.leakage_qbnames) == 0 and len(self.ramsey_qbnames) == 0:
raise ValueError('Please provide either leakage_qbnames or '
'ramsey_qbnames.')
elif len(self.ramsey_qbnames) == 0:
self.ramsey_qbnames = [qbn for qbn in self.qb_names if
qbn not in self.leakage_qbnames]
elif len(self.leakage_qbnames) == 0:
self.leakage_qbnames = [qbn for qbn in self.qb_names if
qbn not in self.ramsey_qbnames]
if len(self.leakage_qbnames) == 0:
self.leakage_qbnames = None
self.phase_key = 'cphase'
if len(self.leakage_qbnames) > 0:
def legend_label_func(qbn, row, gates_list=self.gates_list):
leakage_qbnames = [qb_tup[0] for qb_tup in gates_list]
if qbn in leakage_qbnames:
return f'{qbn} in $|g\\rangle$' if row % 2 != 0 else \
f'{qbn} in $|e\\rangle$'
else:
qbln = [qb_tup for qb_tup in gates_list
if qbn == qb_tup[1]][0][0]
return f'{qbln} in $|g\\rangle$' if row % 2 != 0 else \
f'{qbln} in $|e\\rangle$'
else:
legend_label_func = lambda qbn, row: \
'qbc in $|g\\rangle$' if row % 2 != 0 else \
'qbc in $|e\\rangle$'
self.legend_label_func = legend_label_func
class DynamicPhaseAnalysis(MultiCZgate_Calib_Analysis):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def process_data(self):
super().process_data()
if len(self.ramsey_qbnames) == 0:
self.ramsey_qbnames = self.qb_names
self.phase_key = 'dynamic_phase'
self.legend_label_func = lambda qbn, row: 'no FP' \
if row % 2 != 0 else 'with FP'
class CryoscopeAnalysis(DynamicPhaseAnalysis):
def __init__(self, qb_names, *args, **kwargs):
options_dict = kwargs.get('options_dict', {})
unwrap_phases = options_dict.pop('unwrap_phases', True)
options_dict['unwrap_phases'] = unwrap_phases
kwargs['options_dict'] = options_dict
params_dict = {}
for qbn in qb_names:
s = f'Instrument settings.{qbn}'
params_dict[f'ge_freq_{qbn}'] = s+f'.ge_freq'
kwargs['params_dict'] = params_dict
kwargs['numeric_params'] = list(params_dict)
super().__init__(qb_names, *args, **kwargs)
def process_data(self):
super().process_data()
self.phase_key = 'delta_phase'
def analyze_fit_results(self):
global_delta_tau = self.get_param_value('estimation_window')
task_list = self.get_param_value('task_list')
for qbn in self.qb_names:
delta_tau = deepcopy(global_delta_tau)
if delta_tau is None:
if task_list is None:
log.warning(f'estimation_window is None and task_list '
f'for {qbn} was not found. Assuming no '
f'estimation_window was used.')
else:
task = [t for t in task_list if t['qb'] == qbn]
if not len(task):
raise ValueError(f'{qbn} not found in task_list.')
delta_tau = task[0].get('estimation_window', None)
self.delta_tau = delta_tau
if self.get_param_value('analyze_fit_results_super', True):
super().analyze_fit_results()
self.proc_data_dict['tvals'] = OrderedDict()
for qbn in self.qb_names:
if delta_tau is None:
trunc_lengths = self.sp.get_sweep_params_property(
'values', 1, f'{qbn}_truncation_length')
delta_tau = np.diff(trunc_lengths)
m = delta_tau > 0
delta_tau = delta_tau[m]
phases = self.proc_data_dict['analysis_params_dict'][
f'phases_{qbn}']
delta_phases_vals = -np.diff(phases['val'])[m]
delta_phases_vals = (delta_phases_vals + np.pi) % (
2 * np.pi) - np.pi
delta_phases_errs = (np.sqrt(
np.array(phases['stderr'][1:] ** 2 +
phases['stderr'][:-1] ** 2, dtype=np.float64)))[m]
self.xvals_reduction_func = lambda xvals: \
((xvals[1:] + xvals[:-1]) / 2)[m]
self.proc_data_dict['analysis_params_dict'][
f'{self.phase_key}_{qbn}'] = {
'val': delta_phases_vals, 'stderr': delta_phases_errs}
# remove the entries in analysis_params_dict that are not
# relevant for Cryoscope (pop_loss), since
# these will cause a problem with plotting in this case.
self.proc_data_dict['analysis_params_dict'].pop(
f'population_loss_{qbn}', None)
else:
delta_phases = self.proc_data_dict['analysis_params_dict'][
f'{self.phase_key}_{qbn}']
delta_phases_vals = delta_phases['val']
delta_phases_errs = delta_phases['stderr']
if self.get_param_value('unwrap_phases', False):
if hasattr(delta_tau, '__iter__'):
# unwrap in frequency such that we don't jump more than half
# the nyquist band at any step
df = []
prev_df = 0
for dp, dt in zip(delta_phases_vals, delta_tau):
df.append(dp / (2 * np.pi * dt))
df[-1] += np.round((prev_df - df[-1]) * dt) / dt
prev_df = df[-1]
delta_phases_vals = np.array(df)*(2*np.pi*delta_tau)
else:
delta_phases_vals = np.unwrap((delta_phases_vals + np.pi) %
(2*np.pi) - np.pi)
self.proc_data_dict['analysis_params_dict'][
f'{self.phase_key}_{qbn}']['val'] = delta_phases_vals
delta_freqs = delta_phases_vals/2/np.pi/delta_tau
delta_freqs_errs = delta_phases_errs/2/np.pi/delta_tau
self.proc_data_dict['analysis_params_dict'][f'delta_freq_{qbn}'] = \
{'val': delta_freqs, 'stderr': delta_freqs_errs}
qb_freqs = self.raw_data_dict[f'ge_freq_{qbn}'] + delta_freqs
self.proc_data_dict['analysis_params_dict'][f'freq_{qbn}'] = \
{'val': qb_freqs, 'stderr': delta_freqs_errs}
if hasattr(self, 'xvals_reduction_func') and \
self.xvals_reduction_func is not None:
self.proc_data_dict['tvals'][f'{qbn}'] = \
self.xvals_reduction_func(
self.proc_data_dict['sweep_points_2D_dict'][qbn][
f'{qbn}_truncation_length'])
else:
self.proc_data_dict['tvals'][f'{qbn}'] = \
self.proc_data_dict['sweep_points_2D_dict'][qbn][
f'{qbn}_truncation_length']
self.save_processed_data(key='analysis_params_dict')
self.save_processed_data(key='tvals')
def get_generated_and_measured_pulse(self, qbn=None):
"""
Args:
qbn: specifies for which qubit to calculate the quantities for.
Defaults to the first qubit in qb_names.
Returns: A tuple (tvals_gen, volts_gen, tvals_meas, freqs_meas,
freq_errs_meas, volt_freq_conv)
tvals_gen: time values for the generated fluxpulse
volts_gen: voltages of the generated fluxpulse
tvals_meas: time-values for the measured qubit frequencies
freqs_meas: measured qubit frequencies
freq_errs_meas: errors of measured qubit frequencies
volt_freq_conv: dictionary of fit params for frequency-voltage
conversion
"""
if qbn is None:
qbn = self.qb_names[0]
tvals_meas = self.proc_data_dict['tvals'][qbn]
freqs_meas = self.proc_data_dict['analysis_params_dict'][
f'freq_{qbn}']['val']
freq_errs_meas = self.proc_data_dict['analysis_params_dict'][
f'freq_{qbn}']['stderr']
tvals_gen, volts_gen, volt_freq_conv = self.get_generated_pulse(qbn)
return tvals_gen, volts_gen, tvals_meas, freqs_meas, freq_errs_meas, \
volt_freq_conv
def get_generated_pulse(self, qbn=None, tvals_gen=None, pulse_params=None):
"""
Args:
qbn: specifies for which qubit to calculate the quantities for.
Defaults to the first qubit in qb_names.
Returns: A tuple (tvals_gen, volts_gen, tvals_meas, freqs_meas,
freq_errs_meas, volt_freq_conv)
tvals_gen: time values for the generated fluxpulse
volts_gen: voltages of the generated fluxpulse
volt_freq_conv: dictionary of fit params for frequency-voltage
conversion
"""
if qbn is None:
qbn = self.qb_names[0]
# Flux pulse parameters
# Needs to be changed when support for other pulses is added.
op_dict = {
'pulse_type': f'Instrument settings.{qbn}.flux_pulse_type',
'channel': f'Instrument settings.{qbn}.flux_pulse_channel',
'aux_channels_dict': f'Instrument settings.{qbn}.'
f'flux_pulse_aux_channels_dict',
'amplitude': f'Instrument settings.{qbn}.flux_pulse_amplitude',
'frequency': f'Instrument settings.{qbn}.flux_pulse_frequency',
'phase': f'Instrument settings.{qbn}.flux_pulse_phase',
'pulse_length': f'Instrument settings.{qbn}.'
f'flux_pulse_pulse_length',
'truncation_length': f'Instrument settings.{qbn}.'
f'flux_pulse_truncation_length',
'buffer_length_start': f'Instrument settings.{qbn}.'
f'flux_pulse_buffer_length_start',
'buffer_length_end': f'Instrument settings.{qbn}.'
f'flux_pulse_buffer_length_end',
'extra_buffer_aux_pulse': f'Instrument settings.{qbn}.'
f'flux_pulse_extra_buffer_aux_pulse',
'pulse_delay': f'Instrument settings.{qbn}.'
f'flux_pulse_pulse_delay',
'basis_rotation': f'Instrument settings.{qbn}.'
f'flux_pulse_basis_rotation',
'gaussian_filter_sigma': f'Instrument settings.{qbn}.'
f'flux_pulse_gaussian_filter_sigma',
}
params_dict = {
'volt_freq_conv': f'Instrument settings.{qbn}.'
f'fit_ge_freq_from_flux_pulse_amp',
'flux_channel': f'Instrument settings.{qbn}.'
f'flux_pulse_channel',
'instr_pulsar': f'Instrument settings.{qbn}.'
f'instr_pulsar',
**op_dict
}
dd = self.get_data_from_timestamp_list(params_dict)
if pulse_params is not None:
dd.update(pulse_params)
dd['element_name'] = 'element'
pulse = seg_mod.UnresolvedPulse(dd).pulse_obj
pulse.algorithm_time(0)
if tvals_gen is None:
clk = self.clock(channel=dd['channel'], pulsar=dd['instr_pulsar'])
tvals_gen = np.arange(0, pulse.length, 1 / clk)
volts_gen = pulse.chan_wf(dd['flux_channel'], tvals_gen)
volt_freq_conv = dd['volt_freq_conv']
return tvals_gen, volts_gen, volt_freq_conv
class CZDynamicPhaseAnalysis(MultiQubit_TimeDomain_Analysis):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def process_data(self):
super().process_data()
# convert phases to radians
for qbn in self.qb_names:
sweep_dict = self.proc_data_dict['sweep_points_dict'][qbn]
sweep_dict['sweep_points'] *= np.pi/180
# get data with flux pulse and w/o flux pulse
self.data_with_fp = OrderedDict()
self.data_no_fp = OrderedDict()
for qbn in self.qb_names:
all_data = self.proc_data_dict['data_to_fit'][qbn]
if self.num_cal_points != 0:
all_data = all_data[:-self.num_cal_points]
self.data_with_fp[qbn] = all_data[0: len(all_data)//2]
self.data_no_fp[qbn] = all_data[len(all_data)//2:]
def prepare_fitting(self):
self.fit_dicts = OrderedDict()
for qbn in self.qb_names:
sweep_points = np.unique(
self.proc_data_dict['sweep_points_dict'][qbn][
'msmt_sweep_points'])
for i, data in enumerate([self.data_with_fp[qbn],
self.data_no_fp[qbn]]):
cos_mod = lmfit.Model(fit_mods.CosFunc)
guess_pars = fit_mods.Cos_guess(
model=cos_mod,
t=sweep_points,
data=data, freq_guess=1/(2*np.pi))
guess_pars['frequency'].value = 1/(2*np.pi)
guess_pars['frequency'].vary = False
key = 'cos_fit_{}_{}'.format(qbn, 'wfp' if i == 0 else 'nofp')
self.fit_dicts[key] = {
'fit_fn': fit_mods.CosFunc,
'fit_xvals': {'t': sweep_points},
'fit_yvals': {'data': data},
'guess_pars': guess_pars}
def analyze_fit_results(self):
self.proc_data_dict['analysis_params_dict'] = OrderedDict()
for qbn in self.qb_names:
self.proc_data_dict['analysis_params_dict'][qbn] = OrderedDict()
self.proc_data_dict['analysis_params_dict'][qbn][
'dynamic_phase'] = {
'val': (self.fit_dicts[f'cos_fit_{qbn}_wfp'][
'fit_res'].best_values['phase'] -
self.fit_dicts[f'cos_fit_{qbn}_nofp'][
'fit_res'].best_values['phase']),
'stderr': np.sqrt(
self.fit_dicts[f'cos_fit_{qbn}_wfp'][
'fit_res'].params['phase'].stderr**2 +
self.fit_dicts[f'cos_fit_{qbn}_nofp'][
'fit_res'].params['phase'].stderr**2)
}
self.save_processed_data(key='analysis_params_dict')
def prepare_plots(self):
super().prepare_plots()
for qbn in self.qb_names:
for i, data in enumerate([self.data_with_fp[qbn],
self.data_no_fp[qbn]]):
fit_key = f'<KEY>' if i == 0 else \
f'<KEY>'
plot_name_suffix = 'fit_'+'wfp' if i == 0 else 'nofp'
cal_pts_data = self.proc_data_dict['data_to_fit'][qbn][
-self.num_cal_points:]
base_plot_name = 'Dynamic_phase_' + qbn
self.prepare_projected_data_plot(
fig_name=base_plot_name,
data=np.concatenate((data,cal_pts_data)),
sweep_points=np.unique(
self.proc_data_dict['sweep_points_dict'][qbn][
'sweep_points']),
data_label='with flux pulse' if i == 0 else 'no flux pulse',
plot_name_suffix=qbn + plot_name_suffix,
qb_name=qbn,
do_legend_cal_states=(i == 0))
if self.do_fitting:
fit_res = self.fit_dicts[fit_key]['fit_res']
self.plot_dicts[plot_name_suffix + '_' + qbn] = {
'fig_id': base_plot_name,
'plotfn': self.plot_fit,
'fit_res': fit_res ,
'setlabel': 'cosine fit',
'color': 'r',
'do_legend': i == 0}
textstr = 'Dynamic phase {}:\n\t{:.2f}'.format(
qbn,
self.proc_data_dict['analysis_params_dict'][qbn][
'dynamic_phase']['val']*180/np.pi) + \
r'$^{\circ}$' + \
'$\\pm${:.2f}'.format(
self.proc_data_dict['analysis_params_dict'][qbn][
'dynamic_phase']['stderr']*180/np.pi) + \
r'$^{\circ}$'
fpl = self.get_param_value('flux_pulse_length')
if fpl is not None:
textstr += '\n length: {:.2f} ns'.format(fpl*1e9)
fpa = self.get_param_value('flux_pulse_amp')
if fpa is not None:
textstr += '\n amp: {:.4f} V'.format(fpa)
self.plot_dicts['text_msg_' + qbn] = {
'fig_id': base_plot_name,
'ypos': -0.15,
'xpos': -0.05,
'horizontalalignment': 'left',
'verticalalignment': 'top',
'plotfn': self.plot_text,
'text_string': textstr}
for plot_name in list(self.plot_dicts)[::-1]:
if self.plot_dicts[plot_name].get('do_legend', False):
break
self.plot_dicts[plot_name].update(
{'legend_ncol': 2,
'legend_bbox_to_anchor': (1, -0.15),
'legend_pos': 'upper right'})
class MultiQutrit_Timetrace_Analysis(ba.BaseDataAnalysis):
"""
Analysis class for timetraces, in particular use to compute
Optimal SNR integration weights.
"""
def __init__(self, qb_names=None, auto=True, **kwargs):
"""
Initializes the timetrace analysis class.
Args:
qb_names (list): name of the qubits to analyze (can be a subset
of the measured qubits)
auto (bool): Start analysis automatically
**kwargs:
t_start: timestamp of the first timetrace
t_stop: timestamp of the last timetrace to analyze
options_dict (dict): relevant parameters:
acq_weights_basis (list, dict):
list of basis vectors used to compute optimal weight.
e.g. ["ge", 'gf'], the first basis vector will be the
"e" timetrace minus the "g" timetrace and the second basis
vector is f - g. The first letter in each basis state is the
"reference state", i.e. the one of which the timetrace
is substracted. Can also be passed as a dictionary where
keys are the qubit names and the values are lists of basis states
in case different bases should be used for different qubits.
orthonormalize (bool): Whether or not to orthonormalize the
weight basis
tmax (float): time boundary for the plot (not the weights)
in seconds.
scale_weights (bool): scales the weights near unity to avoid
loss of precision on FPGA if weights are too small
"""
if qb_names is not None:
self.params_dict = {}
for qbn in qb_names:
s = 'Instrument settings.' + qbn
for trans_name in ['ge', 'ef']:
self.params_dict[f'ro_mod_freq_' + qbn] = \
s + f'.ro_mod_freq'
self.numeric_params = list(self.params_dict)
self.qb_names = qb_names
super().__init__(**kwargs)
if auto:
self.run_analysis()
def extract_data(self):
super().extract_data()
if self.qb_names is None:
# get all qubits from cal_points of first timetrace
cp = CalibrationPoints.from_string(
self.get_param_value('cal_points', None, 0))
self.qb_names = deepcopy(cp.qb_names)
self.channel_map = self.get_param_value('channel_map', None,
metadata_index=0)
if self.channel_map is None:
# assume same channel map for all timetraces (pick 0th)
value_names = self.raw_data_dict[0]['value_names']
if np.ndim(value_names) > 0:
value_names = value_names
if 'w' in value_names[0]:
self.channel_map = a_tools.get_qb_channel_map_from_hdf(
self.qb_names, value_names=value_names,
file_path=self.raw_data_dict['folder'])
else:
self.channel_map = {}
for qbn in self.qb_names:
self.channel_map[qbn] = value_names
if len(self.channel_map) == 0:
raise ValueError('No qubit RO channels have been found.')
def process_data(self):
super().process_data()
pdd = self.proc_data_dict
pdd['analysis_params_dict'] = dict()
ana_params = pdd['analysis_params_dict']
ana_params['timetraces'] = defaultdict(dict)
ana_params['optimal_weights'] = defaultdict(dict)
ana_params['optimal_weights_basis_labels'] = defaultdict(dict)
for qbn in self.qb_names:
# retrieve time traces
for i, rdd in enumerate(self.raw_data_dict):
ttrace_per_ro_ch = [rdd["measured_data"][ch]
for ch in self.channel_map[qbn]]
if len(ttrace_per_ro_ch) != 2:
raise NotImplementedError(
'This analysis does not support optimal weight '
f'measurement based on {len(ttrace_per_ro_ch)} ro channels.'
f' Try again with 2 RO channels.')
cp = CalibrationPoints.from_string(
self.get_param_value('cal_points', None, i))
# get state of qubit. There can be only one cal point per sequence
# when using uhf for time traces so it is the 0th state
qb_state = cp.states[0][cp.qb_names.index(qbn)]
# store all timetraces in same pdd for convenience
ana_params['timetraces'][qbn].update(
{qb_state: ttrace_per_ro_ch[0] + 1j *ttrace_per_ro_ch[1]})
timetraces = ana_params['timetraces'][qbn] # for convenience
basis_labels = self.get_param_value('acq_weights_basis', None, 0)
if basis_labels is None:
# guess basis labels from # states measured
basis_labels = ["ge", "ef"] \
if len(ana_params['timetraces'][qbn]) > 2 else ['ge']
if isinstance(basis_labels, dict):
# if different basis for qubits, then select the according one
basis_labels = basis_labels[qbn]
# check that states from the basis are included in mmnt
for bs in basis_labels:
for qb_s in bs:
assert qb_s in timetraces,\
f'State: {qb_s} on {qbn} was not provided in the given ' \
f'timestamps but was requested as part of the basis' \
f' {basis_labels}. Please choose another weight basis.'
basis = np.array([timetraces[b[1]] - timetraces[b[0]]
for b in basis_labels])
# orthonormalize if required
if self.get_param_value("orthonormalize", False):
# We need to consider the integration weights as a vector of
# real numbers to ensure the Gram-Schmidt transformation of the
# weights leads to a linear transformation of the integrated
# readout results (relates to how integration is done on UHF,
# see One Note: Surface 17/ATC75 M136 S17HW02 Cooldown 5/
# 210330 Notes on orthonormalizing readout weights
basis_real = np.hstack((basis.real, basis.imag), )
basis_real = math.gram_schmidt(basis_real.T).T
basis = basis_real[:,:basis_real.shape[1]//2] + \
1j*basis_real[:,basis_real.shape[1]//2:]
basis_labels = [bs + "_ortho" if bs != basis_labels[0] else bs
for bs in basis_labels]
# scale if required
if self.get_param_value('scale_weights', True):
k = np.amax([(np.max(np.abs(b.real)),
np.max(np.abs(b.imag))) for b in basis])
basis /= k
ana_params['optimal_weights'][qbn] = basis
ana_params['optimal_weights_basis_labels'][qbn] = basis_labels
self.save_processed_data()
def prepare_plots(self):
pdd = self.proc_data_dict
rdd = self.raw_data_dict
ana_params = self.proc_data_dict['analysis_params_dict']
for qbn in self.qb_names:
mod_freq = float(
rdd[0].get(f'ro_mod_freq_{qbn}',
self.get_hdf_param_value(f"Instrument settings/{qbn}",
'ro_mod_freq')))
tbase = rdd[0]['hard_sweep_points']
basis_labels = pdd["analysis_params_dict"][
'optimal_weights_basis_labels'][qbn]
title = 'Optimal SNR weights ' + qbn + \
"".join(['\n' + rddi["timestamp"] for rddi in rdd]) \
+ f'\nWeight Basis: {basis_labels}'
plot_name = f"weights_{qbn}"
xlabel = "Time, $t$"
modulation = np.exp(2j * np.pi * mod_freq * tbase)
for ax_id, (state, ttrace) in \
enumerate(ana_params["timetraces"][qbn].items()):
for func, label in zip((np.real, np.imag), ('I', "Q")):
# plot timetraces for each state, I and Q channels
self.plot_dicts[f"{plot_name}_{state}_{label}"] = {
'fig_id': plot_name,
'ax_id': ax_id,
'plotfn': self.plot_line,
'xvals': tbase,
"marker": "",
'yvals': func(ttrace*modulation),
'ylabel': 'Voltage, $V$',
'yunit': 'V',
"sharex": True,
"setdesc": label + f"_{state}",
"setlabel": "",
"do_legend":True,
"legend_pos": "upper right",
'numplotsx': 1,
'numplotsy': len(rdd) + 1, # #states + 1 for weights
'plotsize': (10,
(len(rdd) + 1) * 3), # 3 inches per plot
'title': title if ax_id == 0 else ""}
ax_id = len(ana_params["timetraces"][qbn]) # id plots for weights
for i, weights in enumerate(ana_params['optimal_weights'][qbn]):
for func, label in zip((np.real, np.imag), ('I', "Q")):
self.plot_dicts[f"{plot_name}_weights_{label}_{i}"] = {
'fig_id': plot_name,
'ax_id': ax_id,
'plotfn': self.plot_line,
'xvals': tbase,
'xlabel': xlabel,
"setlabel": "",
"marker": "",
'xunit': 's',
'yvals': func(weights * modulation),
'ylabel': 'Voltage, $V$ (arb.u.)',
"sharex": True,
"xrange": (0, self.get_param_value('tmax', 1200e-9, 0)),
"setdesc": label + f"_{i+1}",
"do_legend": True,
"legend_pos": "upper right",
}
class MultiQutrit_Singleshot_Readout_Analysis(MultiQubit_TimeDomain_Analysis):
"""
Analysis class for parallel SSRO qutrit/qubit calibration. It is a child class
from the tda.MultiQubit_Timedomain_Analysis as it uses the same functions to
- preprocess the data to remove active reset/preselection
- extract the channel map
- reorder the data per qubit
Note that in the future, it might be useful to transfer these functionalities
to the base analysis.
"""
def __init__(self,
options_dict: dict = None, auto=True, **kw):
'''
options dict options:
'nr_bins' : number of bins to use for the histograms
'post_select' :
'post_select_threshold' :
'nr_samples' : amount of different samples (e.g. ground and excited = 2)
'sample_0' : index of first sample (ground-state)
'sample_1' : index of second sample (first excited-state)
'max_datapoints' : maximum amount of datapoints for culumative fit
'log_hist' : use log scale for the y-axis of the 1D histograms
'verbose' : see BaseDataAnalysis
'presentation_mode' : see BaseDataAnalysis
'classif_method': how to classify the data.
'ncc' : default. Nearest Cluster Center
'gmm': gaussian mixture model.
'threshold': finds optimal vertical and horizontal thresholds.
'classif_kw': kw to pass to the classifier
see BaseDataAnalysis for more.
'''
super().__init__(options_dict=options_dict, auto=False,
**kw)
self.params_dict = {
'measurementstring': 'measurementstring',
'measured_data': 'measured_data',
'value_names': 'value_names',
'value_units': 'value_units'}
self.numeric_params = []
self.DEFAULT_CLASSIF = "gmm"
self.classif_method = self.options_dict.get("classif_method",
self.DEFAULT_CLASSIF)
self.create_job(options_dict=options_dict, auto=auto, **kw)
if auto:
self.run_analysis()
def extract_data(self):
super().extract_data()
self.preselection = \
self.get_param_value("preparation_params",
{}).get("preparation_type", "wait") == "preselection"
default_states_info = defaultdict(dict)
default_states_info.update({"g": {"label": r"$|g\rangle$"},
"e": {"label": r"$|e\rangle$"},
"f": {"label": r"$|f\rangle$"}
})
self.states_info = \
self.get_param_value("states_info",
{qbn: deepcopy(default_states_info)
for qbn in self.qb_names})
def process_data(self):
"""
Create the histograms based on the raw data
"""
######################################################
# Separating data into shots for each level #
######################################################
super().process_data()
del self.proc_data_dict['data_to_fit'] # not used in this analysis
n_states = len(self.cp.states)
# prepare data in convenient format, i.e. arrays per qubit and per state
# e.g. {'qb1': {'g': np.array of shape (n_shots, n_ro_ch}, ...}, ...}
shots_per_qb = dict() # store shots per qb and per state
presel_shots_per_qb = dict() # store preselection ro
means = defaultdict(OrderedDict) # store mean per qb for each ro_ch
pdd = self.proc_data_dict # for convenience of notation
for qbn in self.qb_names:
# shape is (n_shots, n_ro_ch) i.e. one column for each ro_ch
shots_per_qb[qbn] = \
np.asarray(list(
pdd['meas_results_per_qb'][qbn].values())).T
# make 2D array in case only one channel (1D array)
if len(shots_per_qb[qbn].shape) == 1:
shots_per_qb[qbn] = np.expand_dims(shots_per_qb[qbn],
axis=-1)
for i, qb_state in enumerate(self.cp.get_states(qbn)[qbn]):
means[qbn][qb_state] = np.mean(shots_per_qb[qbn][i::n_states],
axis=0)
if self.preselection:
# preselection shots were removed so look at raw data
# and look at only the first out of every two readouts
presel_shots_per_qb[qbn] = \
np.asarray(list(
pdd['meas_results_per_qb_raw'][qbn].values())).T[::2]
# make 2D array in case only one channel (1D array)
if len(presel_shots_per_qb[qbn].shape) == 1:
presel_shots_per_qb[qbn] = \
| np.expand_dims(presel_shots_per_qb[qbn], axis=-1) | numpy.expand_dims |
# -*- coding: utf-8 -*-
"""
Created on Tue Jan 18 14:03:35 2022
@author: USER
"""
#3rd party Modules
import numpy as np
#import sys
import warnings
from scipy.stats import qmc
import scipy.stats as sct
import mpi4py.MPI as MPI
class GsaOptions:
def __init__(self, run = True, run_sobol=True, run_morris=True, n_samp_sobol=100000, \
n_samp_morris=4, l_morris=3):
self.run = run
if self.run == False:
self.run_sobol = False
self.run_morris = False
else:
self.run_sobol=run_sobol #Whether to run Sobol (True or False)
self.run_morris=run_morris #Whether to run Morris (True or False)
self.n_samp_sobol = n_samp_sobol #Number of samples to be generated for GSA
self.n_samp_morris = n_samp_morris
self.l_morris=l_morris
pass
class GsaResults:
#
def __init__(self,sobol_base=np.nan, sobol_tot=np.nan, f_a=np.nan, f_b=np.nan, f_d=np.nan, f_ab=np.nan, \
samp_d=np.nan, morris_std=np.nan, morris_mean_abs=np.nan, morris_mean=np.nan):
self.sobol_base=sobol_base
self.sobol_tot=sobol_tot
self.f_a=f_a
self.f_b=f_b
self.f_d=f_d
self.f_ab=f_ab
self.samp_d=samp_d
self.morris_mean_abs=morris_mean_abs
self.morris_mean = morris_mean
self.morris_std=morris_std
pass
##--------------------------------------GSA-----------------------------------------------------
def run_gsa(model, gsa_options, logging = False):
"""Implements global sensitivity analysis using Morris or Sobol analysis.
Parameters
----------
model : Model
Contaings simulation information.
gsa_options : GSAOptions
Contains run settings
Returns
-------
GsaResults
Holds all run results
"""
#GSA implements the following local sensitivity analysis methods on "model" object
# 1) Gets sampling distribution (used only for internal calculations)
# 2) Calculates Sobol Indices
# 3) Performs Morris Screenings (not yet implemented)
# 4) Produces histogram plots for QOI values (not yet implemented)
# Required Inputs: Object of class "model" and object of class "options"
# Outputs: Object of class gsa with fisher and sobol elements
#Load mpi details to keep track of thread number
mpi_comm = MPI.COMM_WORLD
mpi_rank = mpi_comm.Get_rank()
mpi_size = mpi_comm.Get_size()
# Initialize gsa_results in all threads
gsa_results = GsaResults()
#Morris Screening
if gsa_options.run_morris:
#Set non-biased perturbation distance for even l
#Source: <NAME>. 2011. Uncertainty Quanitification. p.333
pert_distance = gsa_options.l_morris/ (2*(gsa_options.l_morris-1))
#Create parameter sample only on thread 0 since it need not be parallelized
# initialize memory location on all threads
morris_samp = np.zeros((gsa_options.n_samp_morris*(model.n_poi+1), model.n_poi),dtype = float)
if logging > 1:
print("initialized morris_samp of size: " + str(morris_samp.shape))
if mpi_rank == 0:
if logging:
print("Generating Morris Sample")
morris_samp = get_morris_poi_sample(model.sample_fcn, gsa_options.n_samp_morris,\
model.n_poi, pert_distance)
mpi_comm.Bcast([morris_samp,MPI.DOUBLE], root = 0)
morris_mean_abs, morris_mean, morris_std = calculate_morris(\
model.eval_fcn, morris_samp, \
pert_distance, logging = logging)
gsa_results.morris_mean_abs=morris_mean_abs
gsa_results.morris_mean = morris_mean
gsa_results.morris_std=morris_std
#Sobol Analysis Un parallelized for now
if gsa_options.run_sobol and mpi_rank == 0:
if logging:
print("Generating Sobol Sample")
#Make Distribution Samples and Calculate model results
[f_a, f_b, f_ab, f_d, samp_d] = get_sobol_sample(model, gsa_options)
#Calculate Sobol Indices
if logging:
print("Calculating Sobol Sample")
[sobol_base, sobol_tot]=calculate_sobol(f_a, f_b, f_ab, f_d)
gsa_results.f_d=f_d
gsa_results.f_a=f_a
gsa_results.f_b=f_b
gsa_results.f_ab=f_ab
gsa_results.samp_d=samp_d
gsa_results.sobol_base=sobol_base
gsa_results.sobol_tot=sobol_tot
#------------broadcast gsa results to other threads--------------------
return gsa_results
###----------------------------------------------------------------------------------------------
###-------------------------------------Support Functions----------------------------------------
###----------------------------------------------------------------------------------------------
def get_sobol_sample(model,gsa_options):
"""Constructs and evaluates sobol samples using predefined sampling distributions.
Currently only function for uniform or saltelli normal
Parameters
----------
model : Model
Contaings simulation information.
gsa_options : GSAOptions
Contains run settings
Returns
-------
np.ndarray
n_samp_sobol x n_qoi array of evaluations of Sobol sample part a
np.ndarray
n_samp_sobol x n_qoi array of evaluations of Sobol sample part b
np.ndarray
n_samp_sobol x n_qoi array x n_poi array of evaluations of mixed Sobol sample ab
np.ndarray
2*n_samp_sobol x n_qoi array of concatenated evaluations of part a and b
np.ndarray
2*n_samp_sobol x n_poi array of concatenated POI samples of part a and b
"""
n_samp_sobol = gsa_options.n_samp_sobol
# Make 2 POI sample matrices with n_samp_sobol samples each
# if np.all(model.dist_type!=np.array(["satelli normal", "satelli uniform"])):
# warnings.warn("Non-satelli sampling algorithm used for Sobol analysis."\
# + " Suggested distribution types are satelli normal "+\
# "and satelli uniform.")
sample_compact = model.sample_fcn(2*n_samp_sobol)
f_compact = model.eval_fcn(sample_compact)
# Seperate sample into a and b for algorithm
samp_a = sample_compact[:n_samp_sobol]
samp_b = sample_compact[n_samp_sobol:]
f_a = f_compact[:n_samp_sobol]
f_b = f_compact[n_samp_sobol:] # n_samp_sobol x nQOI out matrix from B
# Stack the output matrices into a single matrix
f_d = np.concatenate((f_a.copy(), f_b.copy()), axis=0)
# Initialize combined QOI sample matrices
if model.n_qoi == 1:
f_ab = np.empty([n_samp_sobol, model.n_poi])
else:
f_ab = np.empty([n_samp_sobol, model.n_poi, model.n_qoi])
for i_param in range(0, model.n_poi):
# Define sampC to be A with the ith parameter in B
samp_ab = samp_a.copy()
samp_ab[:, i_param] = samp_b[:, i_param].copy()
if model.n_qoi == 1:
f_ab[:, i_param] = model.eval_fcn(samp_ab).squeeze()
else:
f_ab[:, i_param, :] = model.eval_fcn(samp_ab) # n_samp_sobol x nPOI x nQOI tensor
del samp_ab
return f_a, f_b, f_ab, f_d, sample_compact
def calculate_sobol(f_a, f_b, f_ab, f_d):
"""Calculates 1st order and total sobol indices using Saltelli approximation formula.
Parameters
----------
f_a : np.ndarray
n_samp_sobol x n_qoi array of evaluations of Sobol sample part a
f_b : np.ndarray
n_samp_sobol x n_qoi array of evaluations of Sobol sample part b
f_ab : np.ndarray
n_samp_sobol x n_qoi array x n_poi array of evaluations of mixed Sobol sample ab
f_d : np.ndarray
2*n_samp_sobol x n_qoi array of concatenated evaluations of part a and b
Returns
-------
np.ndarray
n_qoi x n_poi array of 1st order Sobol indices
np.ndarray
n_qoi x n_poi array of total Sobol indices
"""
#Calculates calculates sobol indices using satelli approximation method
#Inputs: model object (with eval_fcn, sample, and nParams)
# sobolOptions object
#Determing number of samples, QOIs, and POIs based on inputs
if f_ab.ndim==1:
n_qoi=1
n_poi=1
elif f_ab.ndim==2:
n_qoi=1
n_poi=f_ab.shape[1]
elif f_ab.ndim==3:
n_poi=f_ab.shape[1]
n_qoi=f_ab.shape[2]
else:
raise(Exception('f_ab has greater than 3 dimensions, make sure f_ab is' \
'the squeezed form of n_samp_sobol x nPOI x nQOI'))
#QOI variance
fDvar=np.var(f_d, axis=0)
sobol_base=np.empty((n_qoi, n_poi))
sobol_tot=np.empty((n_qoi, n_poi))
if n_qoi==1:
#Calculate 1st order parameter effects
sobol_base=np.mean(f_b*(f_ab-f_a), axis=0)/(fDvar)
#Caclulate 2nd order parameter effects
sobol_tot=np.mean((f_a-f_ab)**2, axis=0)/(2*fDvar)
else:
for iQOI in range(0,n_qoi):
#Calculate 1st order parameter effects
sobol_base[iQOI,:]=np.mean(f_b[:,[iQOI]]*(f_ab[:,:,iQOI]-f_a[:,[iQOI]]),axis=0)/fDvar[iQOI]
#Caclulate 2nd order parameter effects
sobol_tot[iQOI,:]= np.mean((f_a[:,[iQOI]]-f_ab[:,:,iQOI])**2,axis=0)/(2*fDvar[iQOI])
return sobol_base, sobol_tot
#==============================================================================
#----------------------------------Morris Sampling-----------------------------
#==============================================================================
##--------------------------------calculate_morris-----------------------------
def calculate_morris(eval_fcn, morris_samp, pert_distance, logging = False):
"""Calculates morris samples using information from Model and GsaOptions objects.
Parameters
----------
model : Model
Contaings simulation information.
gsa_options : GSAOptions
Contains run settings
Returns
-------
np.ndarray
n_qoi x n_poi array of morris sensitivity mean indices
np.ndarray
n_qoi x n_poi array of morris sensitivity variance indices
"""
#Evaluate Sample
#Load mpi details to keep track of thread number
mpi_comm = MPI.COMM_WORLD
mpi_rank = mpi_comm.Get_rank()
mpi_size = mpi_comm.Get_size()
if logging and mpi_rank == 0:
print("Evaulating Morris Sample")
if mpi_size == 1:
f_eval_compact = eval_fcn(morris_samp)
else:
f_eval_compact = parallel_eval(eval_fcn, morris_samp, logging = logging)
#Make sure all threads finish collecting f_eval_compact before continuing
mpi_comm.Barrier()
if logging > 1 and mpi_rank == 0:
print("f_eval_compact: " + str(f_eval_compact))
# Initialize Morris indices so that the memory is reserved when broadcasting
if f_eval_compact.ndim == 2:
morris_mean_abs = np.zeros((morris_samp.shape[1], f_eval_compact.shape[1]), dtype = float) # n_poi x n_qoi
morris_mean = np.zeros(morris_mean_abs.shape, dtype = float)
morris_std = np.zeros(morris_mean_abs.shape, dtype = float) # n_poi x n_qoi
else :
morris_mean_abs = np.zeros((morris_samp.shape[1]), dtype = float) # n_poi x n_qoi
morris_mean = np.zeros(morris_mean_abs.shape, dtype = float)
morris_std = np.zeros(morris_mean_abs.shape, dtype = float) # n_poi x n_qoi
# Perform morris calculation only on base thread
if mpi_rank == 0:
#Compute # of pois, qois and samples to ensure consitency
if morris_samp.ndim == 1:
n_poi = 1
elif morris_samp.ndim == 2:
n_poi = morris_samp.shape[1]
else:
raise Exception("More than 2 dimensions in morris_samp")
#Convert to int so it can be used in indexing
n_samp = int(morris_samp.shape[0]/(n_poi+1))
if f_eval_compact.ndim == 2:
n_qoi = f_eval_compact.shape[1]
elif f_eval_compact.ndim ==1:
n_qoi = 1
else:
raise Exception("More than 2 dimensions in f_eval")
#Uncompact Samples
f_eval_seperated = morris_seperate(f_eval_compact, n_samp, n_poi, n_qoi)
morris_samp_seperated = morris_seperate(morris_samp, n_samp, n_poi, n_poi)
if logging > 1:
print("morris samp seperated: " + str(morris_samp_seperated))
#Get which sample perturbs which poi
poi_pert_location = get_poi_pert_location(morris_samp_seperated)
if logging > 1:
print("poi_pert_location: " + str(poi_pert_location))
#initialize data storage arrays with 1 dimension lower if n_qoi =1
if n_qoi > 1:
deriv_approx = np.empty((n_samp, n_poi, n_qoi)) # n_samp x n_poi x n_qoi
else:
deriv_approx = | np.empty((n_samp, n_poi)) | numpy.empty |
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 18 10:35:05 2018
@author: ANDD
"""
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import scipy.io as sio
import matplotlib
#%matplotlib qt
font = {'family' : 'normal',
'weight' : 'bold',
'size' : 22}
matplotlib.rc('font', **font)
Wnam = '15_5_5';top_blocks = [2050,2154, 2200,2245]
#Wnam = '155_6';top_blocks = [2056,2160, 2222,2267]
#Wnam = '155_3';top_blocks = [2076,2180, 2240,2285]
infile = Wnam + '.mat'
Wdict = sio.loadmat(infile)
keys = ['Md','Vp_b', 'Vs_b', 'Rhob_b', 'porosity', 'Vsh', 'Vp_o', 'Vs_o', 'Rhob_o']
cleaned_wdict = {key: Wdict[key].ravel() for key in keys}
df_in = pd.DataFrame.from_dict(cleaned_wdict)
df_in = df_in.dropna()
Md = df_in.Md
Wdict=df_in
def indices(a, func):
return [i for (i, val) in enumerate(a) if func(val)]
def logplot(Vsh,Md,Vp,Vs,Rho,MD,Vp_out,Vs_out,Rho_out):
plt.figure(figsize = (20,10))
plt.subplot(1,4,1)
plt.plot(Vsh,Md)
plt.ylim(np.max(MD)+2,np.min(MD)-2)
plt.xlabel('Vsh (fraction)')
plt.ylabel('Measured depth (m)')
plt.subplot(1,4,2)
plt.plot(Vp,Md)
plt.plot(Vp_out,MD, color = 'red',linewidth=4.0 )
plt.ylim(np.max(MD)+2,np.min(MD)-2)
plt.xlabel('Vp (m/s)')
plt.gca().set_yticks([])
plt.subplot(1,4,3)
plt.plot(Vs,Md)
plt.plot(Vs_out,MD, color = 'red' ,linewidth=4.0)
plt.ylim( | np.max(MD) | numpy.max |
'''
Abbasnejad et al. cars dataset
'''
import datetime
import os
import sys
from sklearn.model_selection._split import KFold
sys.path.append("./python")
sys.path.append("./python/analysis")
sys.path.append("./python/models")
sys.path.append("./python/test")
import matplotlib.pyplot as plt
import logging
logging.basicConfig(level=logging.DEBUG)
# include the paths for the other directories
import time
from scipy.optimize._minimize import minimize
from scipy.stats.stats import kendalltau
from collab_pref_learning_fitc import CollabPrefLearningFITC
import numpy as np
import pandas as pd
from sklearn.metrics import accuracy_score, log_loss
from collab_pref_learning_svi import CollabPrefLearningSVI
# from collab_pref_learning_svi_old import CollabPrefLearningSVI
from gp_pref_learning import GPPrefLearning
from per_user_pref_learning import GPPrefPerUser
verbose = False
def convert_discrete_to_continuous(features, cols_to_convert):
new_features = None
for col in np.arange(features.shape[1]):
if col not in cols_to_convert:
if new_features is None:
new_features = features[:, col:col+1]
else:
new_features = np.concatenate((new_features, features[:, col:col+1]), axis=1)
continue
maxval = np.max(features[:, col])
minval = np.min(features[:, col])
nvals = maxval - minval + 1
vals = np.arange(nvals) + minval
disc_vecs = None
for val in vals:
if disc_vecs is None:
disc_vecs = (features[:, col] == val)[:, None]
else:
disc_vecs = np.concatenate((disc_vecs, (features[:, col]==val)[:, None]), axis=1)
if new_features is None:
new_features = disc_vecs
else:
new_features = np.concatenate((new_features, disc_vecs), axis=1)
return new_features.astype(int)
def run_crowd_GPPL(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr,
u_test=None, i1_test=None, i2_test=None,
ninducing=None, use_common_mean=True, no_local_y=False):
Nfactors = ufeats.shape[0]
if Nfactors > max_facs:
Nfactors = max_facs # this is the maximum
if ninducing is None:
ninducing = np.max([ifeats.shape[0], ufeats.shape[0]])
model = CollabPrefLearningSVI(ifeats.shape[1], ufeats.shape[1], mu0=0, shape_s0=shape_s0, rate_s0=rate_s0,
shape_sy0=1e6, rate_sy0=1e6, ls=None,
nfactors=Nfactors, ninducing=ninducing, max_update_size=max_update_size,
forgetting_rate=forgetting_rate, verbose=verbose, use_lb=True,
use_common_mean_t=use_common_mean, delay=delay)
model.max_Kw_size = max_Kw_size
model.max_iter = 200
model.fit(u_tr, i1_tr, i2_tr, ifeats, prefs_tr, ufeats, use_median_ls=True)
if no_local_y:
model.use_local_obs_posterior_y = False
if u_test is None:
return model
# fpred = model.predict_f(ifeats[active_items], ufeats)
# rho_pred = model.predict(u_test, i1_test, i2_test, ifeats, ufeats)
fpred = model.predict_f()
rho_pred = model.predict(u_test, i1_test, i2_test)
# return predictions of preference scores for training users, new testing users, and pairwise testing labels
return fpred, rho_pred
def run_GPPL_pooled(_, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, __, i1_test, i2_test):
# we can use more inducing points because we don't have to compute GPs for the users and items separately,
# so indcrease the number to make comparison fair.
pool_ninducing = int(ninducing * 2**(1/3.0))
model = GPPrefLearning(ifeats.shape[1], mu0=0, shape_s0=shape_s0, rate_s0=rate_s0, ls_initial=None, use_svi=True,
ninducing=pool_ninducing, max_update_size=max_update_size, forgetting_rate=forgetting_rate,
verbose=verbose)
model.max_iter_VB = 500
model.fit(i1_tr, i2_tr, ifeats, prefs_tr, use_median_ls=True)
fpred, _ = np.tile(model.predict_f(), (1, ufeats.shape[0]))
rho_pred, _ = model.predict(None, i1_test, i2_test)
# return predictions of preference scores for training users, new testing users, and pairwise testing labels
return fpred, rho_pred
def run_GPPL_joint(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test):
# we can use more inducing points because we don't have to compute GPs for the users and items separately,
# so indcrease the number to make comparison fair.
joint_ninducing = int(ninducing * 2**(1/3.0))
model = GPPrefLearning(ifeats.shape[1], mu0=0, shape_s0=shape_s0, rate_s0=rate_s0, ls_initial=None, use_svi=True,
ninducing=joint_ninducing, max_update_size=max_update_size, forgetting_rate=forgetting_rate, verbose=verbose)
model.max_iter_VB = 500
# we need to use only the features for the subset of users in the training set!
# if user features are not very informative, then the inducing points may be fairly useless.
# this might explain why performance is low for joint model and crowd-GPPL.
# However, BMF is and GPPL\u is still too low?
joint_ifeats = np.tile(ifeats, (ufeats.shape[0], 1))
joint_ufeats = np.tile(ufeats, (1, ifeats.shape[0])).reshape((ufeats.shape[0]*ifeats.shape[0], ufeats.shape[1]))
joint_feats = np.concatenate((joint_ifeats, joint_ufeats), axis=1)
i1_tr = i1_tr + (ifeats.shape[0] * u_tr)
i2_tr = i2_tr + (ifeats.shape[0] * u_tr)
model.fit(i1_tr, i2_tr, joint_feats, prefs_tr, use_median_ls=True)
# need to split this up to compute because predict needs pairwise covariance terms and ends up computing full covariance
batchsize = 100
nbatches = int(np.ceil(np.unique(u_test).shape[0] / float(batchsize)))
rho_pred = []
for batch in range(nbatches):
# all of the pairs and features that relate to a batch of users
idxs = (u_test >= (batch) * batchsize) & (u_test < (batch+1) * batchsize)
u_test_b = u_test[idxs]
i1_test_b = i1_test[idxs]
i2_test_b = i2_test[idxs]
joint_feats_idxs_b, pairs_b = np.unique([i1_test_b + (ifeats.shape[0] * u_test_b),
i2_test_b + (ifeats.shape[0] * u_test_b)],
return_inverse=True)
pairs_b = pairs_b.reshape(2, i1_test_b.shape[0])
rho_pred_b, _ = model.predict(joint_feats[joint_feats_idxs_b], pairs_b[0], pairs_b[1])
rho_pred = np.append(rho_pred, rho_pred_b)
joint_ifeats = np.tile(ifeats, (ufeats.shape[0], 1))
joint_ufeats = np.tile(ufeats, (1, ifeats.shape[0])).reshape((ufeats.shape[0]*ifeats.shape[0],
ufeats.shape[1]))
joint_feats = np.concatenate((joint_ifeats, joint_ufeats), axis=1)
fpred, _ = model.predict_f(joint_feats)
fpred = fpred.reshape(ufeats.shape[0], ifeats.shape[0]).T
# return predictions of preference scores for training users, new testing users, and pairwise testing labels
return fpred, rho_pred
def run_GPPL_per_user(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test):
model = GPPrefPerUser(ufeats.shape[0], max_update_size, shape_s0, rate_s0, ifeats.shape[1], ninducing)
model.fit(u_tr, i1_tr, i2_tr, ifeats, prefs_tr, None, False, use_median_ls=True)
fpred = model.predict_f(None, personids=None)
rho_pred = model.predict(u_test, i1_test, i2_test, None, None)
# return predictions of preference scores for training users, new testing users, and pairwise testing labels
return fpred, rho_pred
def run_crowd_GPPL_without_u(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test):
Nfactors = ufeats.shape[0]
if Nfactors > max_facs:
Nfactors = max_facs # this is the maximum
model = CollabPrefLearningSVI(ifeats.shape[1], 0, mu0=0, shape_s0=shape_s0, rate_s0=rate_s0,
shape_sy0=1e6, rate_sy0=1e6, ls=None,
nfactors=Nfactors, ninducing=ninducing, max_update_size=max_update_size,
forgetting_rate=forgetting_rate, verbose=verbose, use_lb=True,
use_common_mean_t=True, delay=delay)
model.max_Kw_size = max_Kw_size
model.max_iter = 500
model.fit(u_tr, i1_tr, i2_tr, ifeats, prefs_tr, None, use_median_ls=True)
fpred = model.predict_f(None, None)
rho_pred = model.predict(u_test, i1_test, i2_test, None, None)
# return predictions of preference scores for training users, new testing users, and pairwise testing labels
return fpred, rho_pred
def run_crowd_BMF(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test):
Nfactors = ufeats.shape[0]
if Nfactors > max_facs:
Nfactors = max_facs # this is the maximum
model = CollabPrefLearningSVI(1, 1, mu0=0, shape_s0=shape_s0, rate_s0=rate_s0,
shape_sy0=1e6, rate_sy0=1e6, ls=None,
nfactors=Nfactors, ninducing=ninducing, max_update_size=max_update_size,
forgetting_rate=forgetting_rate, verbose=verbose, use_lb=True, kernel_func='diagonal',
delay=delay)
model.max_Kw_size = max_Kw_size
model.max_iter = 500
model.fit(u_tr, i1_tr, i2_tr, ifeats, prefs_tr, None, use_median_ls=True)
fpred = model.predict_f(None, None)
rho_pred = model.predict(u_test, i1_test, i2_test, ifeats, None)
# return predictions of preference scores for training users, new testing users, and pairwise testing labels
return fpred, rho_pred
def train_test(method_name, u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test):
if method_name == 'crowd-GPPL':
return run_crowd_GPPL(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test, ninducing=ninducing)
elif method_name == 'crowd-GPPL-ny':
return run_crowd_GPPL(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test, ninducing=ninducing, no_local_y=True)
elif method_name == 'crowd-GPPL-noConsensus':
return run_crowd_GPPL(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test, ninducing=ninducing, use_common_mean=False)
elif method_name == 'crowd-GPPL-noInduc':
return run_crowd_GPPL(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test, ninducing=None)
elif method_name == 'GPPL-pooled':
return run_GPPL_pooled(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test)
elif method_name == 'GPPL-joint':
return run_GPPL_joint(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test)
elif method_name == 'GPPL-per-user':
return run_GPPL_per_user(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test)
elif method_name == 'crowd-GPPL\\u':
return run_crowd_GPPL_without_u(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test)
elif method_name == 'crowd-BMF':
return run_crowd_BMF(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test)
elif method_name == 'crowd-GPPL-FITC\\u-noConsensus': # No common mean, i.e. like Houlsby but SVI
return run_collab_FITC_without_u(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test)
elif method_name == 'crowd-GPPL-FITC\\u':
return run_collab_FITC_without_u(u_tr, i1_tr, i2_tr, ifeats, ufeats, prefs_tr, u_test, i1_test, i2_test, use_common_mean=True)
def run_expt(methods, expt_name):
# predictions from all reps and methods
fpred_all = []
rho_pred_all = []
# metrics from all reps and methods
acc_all = []
logloss_all = []
times_all = []
# for repeatability
np.random.seed(30)
results_path = './results/' + expt_name
if not os.path.exists(results_path):
os.mkdir(results_path)
kfolder = KFold(n_splits=no_folds)
# we switch the training and test sets because we actually want to train on a small subset
for foldidx, (tr_pair_idxs, test_pair_idxs) in enumerate(kfolder.split(prefs)):
if foldidx >= max_no_folds:
break
# Get training and test data
u_tr = userids[tr_pair_idxs]
i1_tr = items1[tr_pair_idxs]
i2_tr = items2[tr_pair_idxs]
prefs_tr = prefs[tr_pair_idxs]
u_test = userids[test_pair_idxs]
i1_test = items1[test_pair_idxs]
i2_test = items2[test_pair_idxs]
prefs_test = prefs[test_pair_idxs]
print(u_tr)
print(i1_tr)
print(i2_tr)
print(prefs_tr)
fpred_r = []
rho_pred_r = []
acc_r = []
logloss_r = []
times_r = []
for m in methods:
# Train and Predict
logging.info("Starting test with method %s..." % (m))
starttime = time.time()
fpred, rho_pred = train_test(m, u_tr, i1_tr, i2_tr, item_features,
user_features, prefs_tr, u_test, i1_test, i2_test)
endtime = time.time()
times_r.append(endtime - starttime)
# Save predictions
fpred_r.append(fpred.flatten())
rho_pred_r.append(rho_pred.flatten())
# Compute metrics
acc_m = accuracy_score(prefs_test, | np.round(rho_pred) | numpy.round |
from __future__ import division
import warnings
from pycircstat import CI
from pycircstat.iterators import index_bootstrap
import numpy as np
from scipy import stats
import pandas as pd
class BaseRegressor(object):
"""
Basic regressor object. Mother class to all other regressors.
Regressors support indexing which is passed to the coefficients.
Regressors also support calling. In this case the prediction function is called.
"""
def __init__(self):
self._coef = None
def istrained(self):
"""
Returns whether the regressor is trained of not.
:return: True if trained
"""
return self._coef is not None
def train(self, *args, **kwargs):
raise NotImplementedError(u"{0:s}.train not implemented".format(self.__class__.__name__))
def test(self, *args, **kwargs):
raise NotImplementedError(u"{0:s}.test not implemented".format(self.__class__.__name__))
def loss(self, x, y, lossfunc, ci=None, bootstrap_iter=1000):
"""
Computes loss function between the predictions f(x) and the true y.
:param x: inputs in radians. If multidimensional, each row must
be a specimen and each column a feature.
:param y: desired outputs in radians. If multidimensional, each
row must be a specimen and each column a feature.
:param lossfunc: loss function, must take an array of input and outputs and compute the loss.
:param ci: confidence interval in [0,1]. If not None, bootstrapping is performed.
:param bootstrap_iter: number of bootstrap iterations if
:return: loss as computed by the loss function.
"""
if ci is not None:
yhat = self.predict(x)
l = [lossfunc(y[idx], yhat[idx]) for idx in index_bootstrap(x.shape[0], bootstrap_iter)]
mu = np.mean(l)
q = 1 - ci
return mu, CI(np.percentile(l, q / 2. * 100), np.percentile(l, 1 - q / 2. * 100))
return lossfunc(y, self.predict(x))
def predict(self, *args, **kwargs):
raise NotImplementedError(u"{0:s}.predict not implemented".format(self.__class__.__name__))
def __getitem__(self, item):
return self._coef.__getitem__(item)
def __setitem__(self, key, value):
return self._coef.__getitem__(key, value)
def __call__(self, *args, **kwargs):
assert self.istrained(), "Regressor must be trained first."
return self.predict(*args, **kwargs)
class CL1stOrderRegression(BaseRegressor):
"""
Implements a circular linear regression model of the form
.. math::
x = m + a \\cos(\\alpha - \\alpha_0)
The actual model is equivalently implemented as
.. math::
x = c_1 \\cos(\\alpha) + c_2 \\sin(\\alpha) + m
References: [Jammalamadaka2001]_
"""
def __init__(self):
super(CL1stOrderRegression, self).__init__()
def train(self, alpha, x):
"""
Estimates the regression coefficients. Only works for 1D data.
:param alpha: independent variable, angles in radians
:param x: dependent variable
"""
assert alpha.shape == x.shape, "x and alpha need to have the same shape"
assert len(alpha.shape) == 1, "regression only implemented for 1D data"
assert len(x.shape) == 1, "regression only implemented for 1D data"
X = np.c_[np.cos(alpha), | np.sin(alpha) | numpy.sin |
"""Defines a polyhedron."""
import numpy as np
import rowan
from scipy.sparse.csgraph import connected_components
from .base_classes import Shape3D
from .convex_polygon import ConvexPolygon, _is_convex
from .polygon import Polygon, _is_simple
from .sphere import Sphere
from .utils import _generate_ax, _set_3d_axes_equal, translate_inertia_tensor
try:
import miniball
MINIBALL = True
except ImportError:
MINIBALL = False
def _face_to_edges(face, reverse=False):
"""Convert a face into a sequence of edges (tuples).
Args:
face (array-like):
A face composed of vertex indices.
reverse (bool):
Whether to return the edges in reverse.
Returns:
list[tuple[int, int]]:
A list of edges where each is a tuple of a pair of vertices.
"""
shift = 1 if reverse else -1
return list(zip(*np.stack((face, np.roll(face, shift)))))
class Polyhedron(Shape3D):
"""A three-dimensional polytope.
A polyhedron is defined by a set of vertices and a set of faces
composed of the vertices. On construction, the faces are reordered
counterclockwise with respect to an outward normal. The polyhedron
provides various standard geometric calculations, such as volume and
surface area. Most features of the polyhedron can be accessed via
properties, including the plane equations defining the faces and the
neighbors of each face.
.. note::
For the purposes of calculations like moments of inertia, the
polyhedron is assumed to be of constant, unit density.
Args:
vertices (:math:`(N, 3)` :class:`numpy.ndarray`):
The vertices of the polyhedron.
faces (list(list)):
The faces of the polyhedron.
faces_are_convex (bool, optional):
Whether or not the faces of the polyhedron are all convex.
This is used to determine whether certain operations like
coplanar face merging are allowed (Default value: False).
Example:
>>> cube = coxeter.shapes.ConvexPolyhedron(
... [[1, 1, 1], [1, -1, 1], [1, 1, -1], [1, -1, -1],
... [-1, 1, 1], [-1, -1, 1], [-1, 1, -1], [-1, -1, -1]])
>>> cube = coxeter.shapes.Polyhedron(
... vertices=cube.vertices, faces=cube.faces)
>>> bounding_sphere = cube.bounding_sphere
>>> import numpy as np
>>> assert np.isclose(bounding_sphere.radius, np.sqrt(3))
>>> cube.center
array([0., 0., 0.])
>>> cube.circumsphere
<coxeter.shapes.sphere.Sphere object at 0x...>
>>> cube.faces
[array([4, 5, 1, 0], dtype=int32), array([0, 2, 6, 4], dtype=int32),
array([6, 7, 5, 4], dtype=int32), array([0, 1, 3, 2], dtype=int32),
array([5, 7, 3, 1], dtype=int32), array([2, 3, 7, 6], dtype=int32)]
>>> cube.gsd_shape_spec
{'type': 'Mesh', 'vertices': [[1.0, 1.0, 1.0], [1.0, -1.0, 1.0],
[1.0, 1.0, -1.0], [1.0, -1.0, -1.0], [-1.0, 1.0, 1.0],
[-1.0, -1.0, 1.0], [-1.0, 1.0, -1.0], [-1.0, -1.0, -1.0]], 'faces':
[array([4, 5, 1, 0], dtype=int32), array([0, 2, 6, 4], dtype=int32),
array([6, 7, 5, 4], dtype=int32), array([0, 1, 3, 2], dtype=int32),
array([5, 7, 3, 1], dtype=int32), array([2, 3, 7, 6], dtype=int32)]}
>>> assert np.allclose(
... cube.inertia_tensor,
... np.diag([16. / 3., 16. / 3., 16. / 3.]))
>>> assert np.isclose(cube.iq, np.pi / 6.)
>>> cube.neighbors
[array([1, 2, 3, 4]), array([0, 2, 3, 5]), array([0, 1, 4, 5]),
array([0, 1, 4, 5]), array([0, 2, 3, 5]), array([1, 2, 3, 4])]
>>> cube.normals
array([[ 0., 0., 1.],
[ 0., 1., -0.],
[-1., 0., 0.],
[ 1., -0., 0.],
[ 0., -1., 0.],
[ 0., 0., -1.]])
>>> cube.num_faces
6
>>> cube.num_vertices
8
>>> assert np.isclose(cube.surface_area, 24.0)
>>> cube.vertices
array([[ 1., 1., 1.],
[ 1., -1., 1.],
[ 1., 1., -1.],
[ 1., -1., -1.],
[-1., 1., 1.],
[-1., -1., 1.],
[-1., 1., -1.],
[-1., -1., -1.]])
>>> assert np.isclose(cube.volume, 8.0)
"""
def __init__(self, vertices, faces, faces_are_convex=None):
self._vertices = np.array(vertices, dtype=np.float64)
self._faces = [face for face in faces]
if faces_are_convex is None:
faces_are_convex = all(len(face) == 3 for face in faces)
self._faces_are_convex = faces_are_convex
self._find_equations()
self._find_neighbors()
def _find_equations(self):
"""Find the plane equations of the polyhedron faces."""
self._equations = np.empty((len(self.faces), 4))
for i, face in enumerate(self.faces):
# The direction of the normal is selected such that vertices that
# are already ordered counterclockwise will point outward.
normal = np.cross(
self.vertices[face[2]] - self.vertices[face[1]],
self.vertices[face[0]] - self.vertices[face[1]],
)
normal /= np.linalg.norm(normal)
self._equations[i, :3] = normal
# Sign conventions chosen to match scipy.spatial.ConvexHull
# We use ax + by + cz + d = 0 (not ax + by + cz = d)
self._equations[i, 3] = -normal.dot(self.vertices[face[0]])
def _find_neighbors(self):
"""Find neighbors of faces."""
self._neighbors = [[] for _ in range(self.num_faces)]
for i, j, _ in self._get_face_intersections():
self._neighbors[i].append(j)
self._neighbors[j].append(i)
self._neighbors = [ | np.array(neigh) | numpy.array |
# This module has been generated automatically from space group information
# obtained from the Computational Crystallography Toolbox
#
"""
Space groups
This module contains a list of all the 230 space groups that can occur in
a crystal. The variable space_groups contains a dictionary that maps
space group numbers and space group names to the corresponding space
group objects.
.. moduleauthor:: <NAME> <<EMAIL>>
"""
#-----------------------------------------------------------------------------
# Copyright (C) 2013 The Mosaic Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file LICENSE.txt, distributed as part of this software.
#-----------------------------------------------------------------------------
import numpy as N
class SpaceGroup(object):
"""
Space group
All possible space group objects are created in this module. Other
modules should access these objects through the dictionary
space_groups rather than create their own space group objects.
"""
def __init__(self, number, symbol, transformations):
"""
:param number: the number assigned to the space group by
international convention
:type number: int
:param symbol: the Hermann-Mauguin space-group symbol as used
in PDB and mmCIF files
:type symbol: str
:param transformations: a list of space group transformations,
each consisting of a tuple of three
integer arrays (rot, tn, td), where
rot is the rotation matrix and tn/td
are the numerator and denominator of the
translation vector. The transformations
are defined in fractional coordinates.
:type transformations: list
"""
self.number = number
self.symbol = symbol
self.transformations = transformations
self.transposed_rotations = N.array([N.transpose(t[0])
for t in transformations])
self.phase_factors = N.exp(N.array([(-2j*N.pi*t[1])/t[2]
for t in transformations]))
def __repr__(self):
return "SpaceGroup(%d, %s)" % (self.number, repr(self.symbol))
def __len__(self):
"""
:return: the number of space group transformations
:rtype: int
"""
return len(self.transformations)
def symmetryEquivalentMillerIndices(self, hkl):
"""
:param hkl: a set of Miller indices
:type hkl: Scientific.N.array_type
:return: a tuple (miller_indices, phase_factor) of two arrays
of length equal to the number of space group
transformations. miller_indices contains the Miller
indices of each reflection equivalent by symmetry to the
reflection hkl (including hkl itself as the first element).
phase_factor contains the phase factors that must be applied
to the structure factor of reflection hkl to obtain the
structure factor of the symmetry equivalent reflection.
:rtype: tuple
"""
hkls = N.dot(self.transposed_rotations, hkl)
p = N.multiply.reduce(self.phase_factors**hkl, -1)
return hkls, p
space_groups = {}
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(1, 'P 1', transformations)
space_groups[1] = sg
space_groups['P 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(2, 'P -1', transformations)
space_groups[2] = sg
space_groups['P -1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(3, 'P 1 2 1', transformations)
space_groups[3] = sg
space_groups['P 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(4, 'P 1 21 1', transformations)
space_groups[4] = sg
space_groups['P 1 21 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(5, 'C 1 2 1', transformations)
space_groups[5] = sg
space_groups['C 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(6, 'P 1 m 1', transformations)
space_groups[6] = sg
space_groups['P 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(7, 'P 1 c 1', transformations)
space_groups[7] = sg
space_groups['P 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(8, 'C 1 m 1', transformations)
space_groups[8] = sg
space_groups['C 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(9, 'C 1 c 1', transformations)
space_groups[9] = sg
space_groups['C 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(10, 'P 1 2/m 1', transformations)
space_groups[10] = sg
space_groups['P 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(11, 'P 1 21/m 1', transformations)
space_groups[11] = sg
space_groups['P 1 21/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(12, 'C 1 2/m 1', transformations)
space_groups[12] = sg
space_groups['C 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(13, 'P 1 2/c 1', transformations)
space_groups[13] = sg
space_groups['P 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(14, 'P 1 21/c 1', transformations)
space_groups[14] = sg
space_groups['P 1 21/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(15, 'C 1 2/c 1', transformations)
space_groups[15] = sg
space_groups['C 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(16, 'P 2 2 2', transformations)
space_groups[16] = sg
space_groups['P 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(17, 'P 2 2 21', transformations)
space_groups[17] = sg
space_groups['P 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(18, 'P 21 21 2', transformations)
space_groups[18] = sg
space_groups['P 21 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(19, 'P 21 21 21', transformations)
space_groups[19] = sg
space_groups['P 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(20, 'C 2 2 21', transformations)
space_groups[20] = sg
space_groups['C 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(21, 'C 2 2 2', transformations)
space_groups[21] = sg
space_groups['C 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(22, 'F 2 2 2', transformations)
space_groups[22] = sg
space_groups['F 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(23, 'I 2 2 2', transformations)
space_groups[23] = sg
space_groups['I 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(24, 'I 21 21 21', transformations)
space_groups[24] = sg
space_groups['I 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(25, 'P m m 2', transformations)
space_groups[25] = sg
space_groups['P m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(26, 'P m c 21', transformations)
space_groups[26] = sg
space_groups['P m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(27, 'P c c 2', transformations)
space_groups[27] = sg
space_groups['P c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(28, 'P m a 2', transformations)
space_groups[28] = sg
space_groups['P m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(29, 'P c a 21', transformations)
space_groups[29] = sg
space_groups['P c a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(30, 'P n c 2', transformations)
space_groups[30] = sg
space_groups['P n c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(31, 'P m n 21', transformations)
space_groups[31] = sg
space_groups['P m n 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(32, 'P b a 2', transformations)
space_groups[32] = sg
space_groups['P b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(33, 'P n a 21', transformations)
space_groups[33] = sg
space_groups['P n a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(34, 'P n n 2', transformations)
space_groups[34] = sg
space_groups['P n n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(35, 'C m m 2', transformations)
space_groups[35] = sg
space_groups['C m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(36, 'C m c 21', transformations)
space_groups[36] = sg
space_groups['C m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(37, 'C c c 2', transformations)
space_groups[37] = sg
space_groups['C c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(38, 'A m m 2', transformations)
space_groups[38] = sg
space_groups['A m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(39, 'A b m 2', transformations)
space_groups[39] = sg
space_groups['A b m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(40, 'A m a 2', transformations)
space_groups[40] = sg
space_groups['A m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(41, 'A b a 2', transformations)
space_groups[41] = sg
space_groups['A b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(42, 'F m m 2', transformations)
space_groups[42] = sg
space_groups['F m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(43, 'F d d 2', transformations)
space_groups[43] = sg
space_groups['F d d 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(44, 'I m m 2', transformations)
space_groups[44] = sg
space_groups['I m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(45, 'I b a 2', transformations)
space_groups[45] = sg
space_groups['I b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(46, 'I m a 2', transformations)
space_groups[46] = sg
space_groups['I m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(47, 'P m m m', transformations)
space_groups[47] = sg
space_groups['P m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(48, 'P n n n :2', transformations)
space_groups[48] = sg
space_groups['P n n n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(49, 'P c c m', transformations)
space_groups[49] = sg
space_groups['P c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(50, 'P b a n :2', transformations)
space_groups[50] = sg
space_groups['P b a n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(51, 'P m m a', transformations)
space_groups[51] = sg
space_groups['P m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(52, 'P n n a', transformations)
space_groups[52] = sg
space_groups['P n n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(53, 'P m n a', transformations)
space_groups[53] = sg
space_groups['P m n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(54, 'P c c a', transformations)
space_groups[54] = sg
space_groups['P c c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(55, 'P b a m', transformations)
space_groups[55] = sg
space_groups['P b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(56, 'P c c n', transformations)
space_groups[56] = sg
space_groups['P c c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(57, 'P b c m', transformations)
space_groups[57] = sg
space_groups['P b c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(58, 'P n n m', transformations)
space_groups[58] = sg
space_groups['P n n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(59, 'P m m n :2', transformations)
space_groups[59] = sg
space_groups['P m m n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(60, 'P b c n', transformations)
space_groups[60] = sg
space_groups['P b c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(61, 'P b c a', transformations)
space_groups[61] = sg
space_groups['P b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(62, 'P n m a', transformations)
space_groups[62] = sg
space_groups['P n m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(63, 'C m c m', transformations)
space_groups[63] = sg
space_groups['C m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(64, 'C m c a', transformations)
space_groups[64] = sg
space_groups['C m c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(65, 'C m m m', transformations)
space_groups[65] = sg
space_groups['C m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(66, 'C c c m', transformations)
space_groups[66] = sg
space_groups['C c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(67, 'C m m a', transformations)
space_groups[67] = sg
space_groups['C m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(68, 'C c c a :2', transformations)
space_groups[68] = sg
space_groups['C c c a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(69, 'F m m m', transformations)
space_groups[69] = sg
space_groups['F m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(70, 'F d d d :2', transformations)
space_groups[70] = sg
space_groups['F d d d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(71, 'I m m m', transformations)
space_groups[71] = sg
space_groups['I m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(72, 'I b a m', transformations)
space_groups[72] = sg
space_groups['I b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(73, 'I b c a', transformations)
space_groups[73] = sg
space_groups['I b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(74, 'I m m a', transformations)
space_groups[74] = sg
space_groups['I m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(75, 'P 4', transformations)
space_groups[75] = sg
space_groups['P 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(76, 'P 41', transformations)
space_groups[76] = sg
space_groups['P 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(77, 'P 42', transformations)
space_groups[77] = sg
space_groups['P 42'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(78, 'P 43', transformations)
space_groups[78] = sg
space_groups['P 43'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(79, 'I 4', transformations)
space_groups[79] = sg
space_groups['I 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(80, 'I 41', transformations)
space_groups[80] = sg
space_groups['I 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(81, 'P -4', transformations)
space_groups[81] = sg
space_groups['P -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(82, 'I -4', transformations)
space_groups[82] = sg
space_groups['I -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(83, 'P 4/m', transformations)
space_groups[83] = sg
space_groups['P 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(84, 'P 42/m', transformations)
space_groups[84] = sg
space_groups['P 42/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(85, 'P 4/n :2', transformations)
space_groups[85] = sg
space_groups['P 4/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(86, 'P 42/n :2', transformations)
space_groups[86] = sg
space_groups['P 42/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(87, 'I 4/m', transformations)
space_groups[87] = sg
space_groups['I 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(88, 'I 41/a :2', transformations)
space_groups[88] = sg
space_groups['I 41/a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(89, 'P 4 2 2', transformations)
space_groups[89] = sg
space_groups['P 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(90, 'P 4 21 2', transformations)
space_groups[90] = sg
space_groups['P 4 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(91, 'P 41 2 2', transformations)
space_groups[91] = sg
space_groups['P 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(92, 'P 41 21 2', transformations)
space_groups[92] = sg
space_groups['P 41 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(93, 'P 42 2 2', transformations)
space_groups[93] = sg
space_groups['P 42 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(94, 'P 42 21 2', transformations)
space_groups[94] = sg
space_groups['P 42 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(95, 'P 43 2 2', transformations)
space_groups[95] = sg
space_groups['P 43 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(96, 'P 43 21 2', transformations)
space_groups[96] = sg
space_groups['P 43 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(97, 'I 4 2 2', transformations)
space_groups[97] = sg
space_groups['I 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(98, 'I 41 2 2', transformations)
space_groups[98] = sg
space_groups['I 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(99, 'P 4 m m', transformations)
space_groups[99] = sg
space_groups['P 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(100, 'P 4 b m', transformations)
space_groups[100] = sg
space_groups['P 4 b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(101, 'P 42 c m', transformations)
space_groups[101] = sg
space_groups['P 42 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(102, 'P 42 n m', transformations)
space_groups[102] = sg
space_groups['P 42 n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(103, 'P 4 c c', transformations)
space_groups[103] = sg
space_groups['P 4 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(104, 'P 4 n c', transformations)
space_groups[104] = sg
space_groups['P 4 n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(105, 'P 42 m c', transformations)
space_groups[105] = sg
space_groups['P 42 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(106, 'P 42 b c', transformations)
space_groups[106] = sg
space_groups['P 42 b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(107, 'I 4 m m', transformations)
space_groups[107] = sg
space_groups['I 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(108, 'I 4 c m', transformations)
space_groups[108] = sg
space_groups['I 4 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(109, 'I 41 m d', transformations)
space_groups[109] = sg
space_groups['I 41 m d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(110, 'I 41 c d', transformations)
space_groups[110] = sg
space_groups['I 41 c d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(111, 'P -4 2 m', transformations)
space_groups[111] = sg
space_groups['P -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(112, 'P -4 2 c', transformations)
space_groups[112] = sg
space_groups['P -4 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(113, 'P -4 21 m', transformations)
space_groups[113] = sg
space_groups['P -4 21 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(114, 'P -4 21 c', transformations)
space_groups[114] = sg
space_groups['P -4 21 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(115, 'P -4 m 2', transformations)
space_groups[115] = sg
space_groups['P -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(116, 'P -4 c 2', transformations)
space_groups[116] = sg
space_groups['P -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(117, 'P -4 b 2', transformations)
space_groups[117] = sg
space_groups['P -4 b 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(118, 'P -4 n 2', transformations)
space_groups[118] = sg
space_groups['P -4 n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(119, 'I -4 m 2', transformations)
space_groups[119] = sg
space_groups['I -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(120, 'I -4 c 2', transformations)
space_groups[120] = sg
space_groups['I -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(121, 'I -4 2 m', transformations)
space_groups[121] = sg
space_groups['I -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(122, 'I -4 2 d', transformations)
space_groups[122] = sg
space_groups['I -4 2 d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(123, 'P 4/m m m', transformations)
space_groups[123] = sg
space_groups['P 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(124, 'P 4/m c c', transformations)
space_groups[124] = sg
space_groups['P 4/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(125, 'P 4/n b m :2', transformations)
space_groups[125] = sg
space_groups['P 4/n b m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(126, 'P 4/n n c :2', transformations)
space_groups[126] = sg
space_groups['P 4/n n c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(127, 'P 4/m b m', transformations)
space_groups[127] = sg
space_groups['P 4/m b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(128, 'P 4/m n c', transformations)
space_groups[128] = sg
space_groups['P 4/m n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(129, 'P 4/n m m :2', transformations)
space_groups[129] = sg
space_groups['P 4/n m m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(130, 'P 4/n c c :2', transformations)
space_groups[130] = sg
space_groups['P 4/n c c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(131, 'P 42/m m c', transformations)
space_groups[131] = sg
space_groups['P 42/m m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(132, 'P 42/m c m', transformations)
space_groups[132] = sg
space_groups['P 42/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(133, 'P 42/n b c :2', transformations)
space_groups[133] = sg
space_groups['P 42/n b c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(134, 'P 42/n n m :2', transformations)
space_groups[134] = sg
space_groups['P 42/n n m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(135, 'P 42/m b c', transformations)
space_groups[135] = sg
space_groups['P 42/m b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(136, 'P 42/m n m', transformations)
space_groups[136] = sg
space_groups['P 42/m n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(137, 'P 42/n m c :2', transformations)
space_groups[137] = sg
space_groups['P 42/n m c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(138, 'P 42/n c m :2', transformations)
space_groups[138] = sg
space_groups['P 42/n c m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(139, 'I 4/m m m', transformations)
space_groups[139] = sg
space_groups['I 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(140, 'I 4/m c m', transformations)
space_groups[140] = sg
space_groups['I 4/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(141, 'I 41/a m d :2', transformations)
space_groups[141] = sg
space_groups['I 41/a m d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(142, 'I 41/a c d :2', transformations)
space_groups[142] = sg
space_groups['I 41/a c d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(143, 'P 3', transformations)
space_groups[143] = sg
space_groups['P 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(144, 'P 31', transformations)
space_groups[144] = sg
space_groups['P 31'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(145, 'P 32', transformations)
space_groups[145] = sg
space_groups['P 32'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(146, 'R 3 :H', transformations)
space_groups[146] = sg
space_groups['R 3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(147, 'P -3', transformations)
space_groups[147] = sg
space_groups['P -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(148, 'R -3 :H', transformations)
space_groups[148] = sg
space_groups['R -3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(149, 'P 3 1 2', transformations)
space_groups[149] = sg
space_groups['P 3 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(150, 'P 3 2 1', transformations)
space_groups[150] = sg
space_groups['P 3 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(151, 'P 31 1 2', transformations)
space_groups[151] = sg
space_groups['P 31 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(152, 'P 31 2 1', transformations)
space_groups[152] = sg
space_groups['P 31 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(153, 'P 32 1 2', transformations)
space_groups[153] = sg
space_groups['P 32 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(154, 'P 32 2 1', transformations)
space_groups[154] = sg
space_groups['P 32 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(155, 'R 3 2 :H', transformations)
space_groups[155] = sg
space_groups['R 3 2 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(156, 'P 3 m 1', transformations)
space_groups[156] = sg
space_groups['P 3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(157, 'P 3 1 m', transformations)
space_groups[157] = sg
space_groups['P 3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(158, 'P 3 c 1', transformations)
space_groups[158] = sg
space_groups['P 3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(159, 'P 3 1 c', transformations)
space_groups[159] = sg
space_groups['P 3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = | N.array([0,0,0]) | numpy.array |
import os
import time
import msgpack
import numpy as np
from loguru import logger
from msgpack import Unpacker
from numpy import typing as npt
from twisted.internet import reactor
from twisted.internet.endpoints import TCP4ServerEndpoint
from twisted.internet.interfaces import IAddress
from twisted.internet.protocol import Factory, Protocol, connectionDone
from twisted.python import failure
def _sieve(target_n: int) -> npt.NDArray:
assert 1 < target_n
candidates = np.ones(shape=(target_n + 1,), dtype=bool)
i = 2
while i <= np.sqrt(target_n):
if candidates[i]:
j = | np.square(i) | numpy.square |
"""
gui/average3
~~~~~~~~~~~~~~~~~~~~
Graphical user interface for three-dimensional averaging of particles
:author: <NAME>, 2017-2018
:copyright: Copyright (c) 2017-2018 Jungmann Lab, MPI of Biochemistry
"""
import os.path
import sys
import traceback
import colorsys
import matplotlib.pyplot as plt
import numba
import numpy as np
import scipy
from scipy import signal
from PyQt5 import QtCore, QtGui, QtWidgets
from .. import io, lib, render
from numpy.lib.recfunctions import stack_arrays
from cmath import rect, phase
from tqdm import tqdm
import scipy.ndimage.filters
DEFAULT_OVERSAMPLING = 1.0
INITIAL_REL_MAXIMUM = 2.0
ZOOM = 10 / 7
N_GROUP_COLORS = 8
@numba.jit(nopython=True, nogil=True)
def render_hist(x, y, oversampling, t_min, t_max):
n_pixel = int(np.ceil(oversampling * (t_max - t_min)))
in_view = (x > t_min) & (y > t_min) & (x < t_max) & (y < t_max)
x = x[in_view]
y = y[in_view]
x = oversampling * (x - t_min)
y = oversampling * (y - t_min)
image = np.zeros((n_pixel, n_pixel), dtype=np.float32)
render._fill(image, x, y)
return len(x), image
@numba.jit(nopython=True, nogil=True)
def render_histxyz(a, b, oversampling, a_min, a_max, b_min, b_max):
n_pixel_a = int(np.ceil(oversampling * (a_max - a_min)))
n_pixel_b = int(np.ceil(oversampling * (b_max - b_min)))
in_view = (a > a_min) & (b > b_min) & (a < a_max) & (b < b_max)
a = a[in_view]
b = b[in_view]
a = oversampling * (a - a_min)
b = oversampling * (b - b_min)
image = np.zeros((n_pixel_b, n_pixel_a), dtype=np.float32)
render._fill(image, a, b)
return len(a), image
def rotate_axis(axis, vx, vy, vz, angle, pixelsize):
if axis == "z":
vx_rot = np.cos(angle) * vx - np.sin(angle) * vy
vy_rot = np.sin(angle) * vx + np.cos(angle) * vy
vz_rot = vz
elif axis == "y":
vx_rot = np.cos(angle) * vx + np.sin(angle) * np.divide(vz, pixelsize)
vy_rot = vy
vz_rot = -np.sin(angle) * vx * pixelsize + np.cos(angle) * vz
elif axis == "x":
vx_rot = vx
vy_rot = np.cos(angle) * vy - np.sin(angle) * np.divide(vz, pixelsize)
vz_rot = np.sin(angle) * vy * pixelsize + np.cos(angle) * vz
return vx_rot, vy_rot, vz_rot
def compute_xcorr(CF_image_avg, image):
F_image = np.fft.fft2(image)
xcorr = np.fft.fftshift(np.real(np.fft.ifft2((F_image * CF_image_avg))))
return xcorr
class ParametersDialog(QtWidgets.QDialog):
def __init__(self, window):
super().__init__(window)
self.window = window
self.setWindowTitle("Parameters")
self.setModal(False)
grid = QtWidgets.QGridLayout(self)
grid.addWidget(QtWidgets.QLabel("Oversampling:"), 0, 0)
self.oversampling = QtWidgets.QDoubleSpinBox()
self.oversampling.setRange(1, 200)
self.oversampling.setValue(DEFAULT_OVERSAMPLING)
self.oversampling.setDecimals(1)
self.oversampling.setKeyboardTracking(False)
self.oversampling.valueChanged.connect(self.window.updateLayout)
grid.addWidget(self.oversampling, 0, 1)
self.iterations = QtWidgets.QSpinBox()
self.iterations.setRange(1, 1)
self.iterations.setValue(1)
class View(QtWidgets.QLabel):
def __init__(self, window):
super().__init__()
self.window = window
self.setMinimumSize(1, 1)
self.setAlignment(QtCore.Qt.AlignCenter)
self.setAcceptDrops(True)
self._pixmap = None
def dragEnterEvent(self, event):
if event.mimeData().hasUrls():
event.accept()
else:
event.ignore()
def dropEvent(self, event):
urls = event.mimeData().urls()
path = urls[0].toLocalFile()
ext = os.path.splitext(path)[1].lower()
if ext == ".hdf5":
self.open(path)
def resizeEvent(self, event):
if self._pixmap is not None:
self.set_pixmap(self._pixmap)
def set_image(self, image):
cmap = np.uint8(np.round(255 * plt.get_cmap("magma")(np.arange(256))))
image /= image.max()
image = np.minimum(image, 1.0)
image = np.round(255 * image).astype("uint8")
Y, X = image.shape
self._bgra = np.zeros((Y, X, 4), dtype=np.uint8, order="C")
self._bgra[..., 0] = cmap[:, 2][image]
self._bgra[..., 1] = cmap[:, 1][image]
self._bgra[..., 2] = cmap[:, 0][image]
qimage = QtGui.QImage(self._bgra.data, X, Y, QtGui.QImage.Format_RGB32)
self._pixmap = QtGui.QPixmap.fromImage(qimage)
self.set_pixmap(self._pixmap)
def set_pixmap(self, pixmap):
self.setPixmap(
pixmap.scaled(
self.width(),
self.height(),
QtCore.Qt.KeepAspectRatio,
QtCore.Qt.FastTransformation,
)
)
def update_image(self, *args):
oversampling = self.window.parameters_dialog.oversampling.value()
t_min = -self.r
t_max = self.r
N_avg, image_avg = render.render_hist(
self.locs, oversampling, t_min, t_min, t_max, t_max
)
self.set_image(image_avg)
class DatasetDialog(QtWidgets.QDialog):
def __init__(self, window):
super().__init__(window)
self.window = window
self.setWindowTitle("Datasets")
self.setModal(False)
self.layout = QtWidgets.QVBoxLayout()
self.checks = []
self.setLayout(self.layout)
def add_entry(self, path):
c = QtWidgets.QCheckBox(path)
self.layout.addWidget(c)
self.checks.append(c)
self.checks[-1].setChecked(True)
class Window(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Picasso: Average3")
self.resize(1024, 512)
this_directory = os.path.dirname(os.path.realpath(__file__))
icon_path = os.path.join(this_directory, "icons", "average.ico")
icon = QtGui.QIcon(icon_path)
self.setWindowIcon(icon)
self.setAcceptDrops(True)
self.parameters_dialog = ParametersDialog(self)
self.dataset_dialog = DatasetDialog(self)
menu_bar = self.menuBar()
file_menu = menu_bar.addMenu("File")
open_action = file_menu.addAction("Open")
open_action.setShortcut(QtGui.QKeySequence.Open)
open_action.triggered.connect(self.open)
file_menu.addAction(open_action)
save_action = file_menu.addAction("Save")
save_action.setShortcut(QtGui.QKeySequence.Save)
save_action.triggered.connect(self.save)
file_menu.addAction(save_action)
process_menu = menu_bar.addMenu("Process")
parameters_action = process_menu.addAction("Parameters")
parameters_action.setShortcut("Ctrl+P")
parameters_action.triggered.connect(self.parameters_dialog.show)
dataset_action = process_menu.addAction("Datasets")
dataset_action.triggered.connect(self.dataset_dialog.show)
self.status_bar = self.statusBar()
self._pixmap = None
self.locs = []
self.z_state = []
self.group_index = []
self.infos = []
self.locs_paths = []
self._mode = "Zoom"
self._pan = False
self._size_hint = (768, 768)
self.n_locs = 0
self._picks = []
self.index_blocks = []
self._drift = []
# Define DisplaySettingsDialog
self.viewxy = QtWidgets.QLabel("")
self.viewxz = QtWidgets.QLabel("")
self.viewyz = QtWidgets.QLabel("")
self.viewcp = QtWidgets.QLabel("")
minsize = 512
self.viewxy.setFixedWidth(minsize)
self.viewxy.setFixedHeight(minsize)
self.viewxz.setFixedWidth(minsize)
self.viewxz.setFixedHeight(minsize)
self.viewyz.setFixedWidth(minsize)
self.viewyz.setFixedHeight(minsize)
self.viewcp.setFixedWidth(minsize)
self.viewcp.setFixedHeight(minsize)
# Define layout
display_groupbox = QtWidgets.QGroupBox("Display")
displaygrid = QtWidgets.QGridLayout(display_groupbox)
displaygrid.addWidget(QtWidgets.QLabel("XY"), 0, 0)
displaygrid.addWidget(self.viewxy, 1, 0)
displaygrid.addWidget(QtWidgets.QLabel("XZ"), 0, 1)
displaygrid.addWidget(self.viewxz, 1, 1)
displaygrid.addWidget(QtWidgets.QLabel("YZ"), 2, 0)
displaygrid.addWidget(self.viewyz, 3, 0)
displaygrid.addWidget(QtWidgets.QLabel("CP"), 2, 1)
displaygrid.addWidget(self.viewcp, 3, 1)
button_groupbox = QtWidgets.QGroupBox("Buttons")
buttongrid = QtWidgets.QGridLayout(button_groupbox)
rotation_groupbox = QtWidgets.QGroupBox("Rotation + Translation")
rotationgrid = QtWidgets.QGridLayout(rotation_groupbox)
centerofmassbtn = QtWidgets.QPushButton("Center of Mass XYZ")
axis_groupbox = QtWidgets.QGroupBox("Axis")
axisgrid = QtWidgets.QGridLayout(axis_groupbox)
self.x_axisbtn = QtWidgets.QRadioButton("X")
self.y_axisbtn = QtWidgets.QRadioButton("Y")
self.z_axisbtn = QtWidgets.QRadioButton("Z")
self.z_axisbtn.setChecked(True)
axisgrid.addWidget(self.x_axisbtn, 0, 0)
axisgrid.addWidget(self.y_axisbtn, 0, 1)
axisgrid.addWidget(self.z_axisbtn, 0, 2)
proj_groupbox = QtWidgets.QGroupBox("Projection")
projgrid = QtWidgets.QGridLayout(proj_groupbox)
self.xy_projbtn = QtWidgets.QRadioButton("XY")
self.yz_projbtn = QtWidgets.QRadioButton("YZ")
self.xz_projbtn = QtWidgets.QRadioButton("XZ")
self.xy_projbtn.setChecked(True)
projgrid.addWidget(self.xy_projbtn, 0, 0)
projgrid.addWidget(self.yz_projbtn, 0, 1)
projgrid.addWidget(self.xz_projbtn, 0, 2)
rotatebtn = QtWidgets.QPushButton("Rotate")
self.radio_sym = QtWidgets.QRadioButton("x symmetry")
self.symEdit = QtWidgets.QSpinBox()
self.symEdit.setRange(2, 100)
self.symEdit.setValue(8)
self.radio_sym_custom = QtWidgets.QRadioButton("custom symmetry")
self.symcustomEdit = QtWidgets.QLineEdit("90,180,270")
deg_groupbox = QtWidgets.QGroupBox("Degrees")
deggrid = QtWidgets.QGridLayout(deg_groupbox)
self.full_degbtn = QtWidgets.QRadioButton("Full")
self.part_degbtn = QtWidgets.QRadioButton("Part")
self.degEdit = QtWidgets.QTextEdit()
self.degEdit = QtWidgets.QSpinBox()
self.degEdit.setRange(1, 10)
self.degEdit.setValue(5)
deggrid.addWidget(self.full_degbtn, 0, 0)
deggrid.addWidget(self.part_degbtn, 0, 1)
deggrid.addWidget(self.degEdit, 0, 2)
self.full_degbtn.setChecked(True)
# Rotation Groupbox
rotationgrid.addWidget(axis_groupbox, 0, 0, 1, 2)
rotationgrid.addWidget(proj_groupbox, 1, 0, 1, 2)
rotationgrid.addWidget(deg_groupbox, 2, 0, 1, 2)
rotationgrid.addWidget(rotatebtn, 3, 0, 1, 2)
rotationgrid.addWidget(self.symEdit, 4, 0)
rotationgrid.addWidget(self.radio_sym, 4, 1)
rotationgrid.addWidget(self.radio_sym_custom, 5, 0)
rotationgrid.addWidget(self.symcustomEdit, 5, 1)
buttongrid.addWidget(centerofmassbtn, 0, 0)
buttongrid.addWidget(rotation_groupbox, 1, 0)
centerofmassbtn.clicked.connect(self.centerofmass)
rotatebtn.clicked.connect(self.rotate_groups)
self.translatebtn = QtWidgets.QCheckBox("Translate only")
self.flipbtn = QtWidgets.QCheckBox("Consider flipped structures")
self.alignxbtn = QtWidgets.QPushButton("Align X")
self.alignybtn = QtWidgets.QPushButton("Align Y")
self.alignzzbtn = QtWidgets.QPushButton("Align Z_Z")
self.alignzybtn = QtWidgets.QPushButton("Align Z_Y")
self.translatexbtn = QtWidgets.QPushButton("Translate X")
self.translateybtn = QtWidgets.QPushButton("Translate Y")
self.translatezbtn = QtWidgets.QPushButton("Translate Z")
self.rotatexy_convbtn = QtWidgets.QPushButton("Rotate XY - Convolution")
self.scorebtn = QtWidgets.QPushButton("Calculate Score")
operate_groupbox = QtWidgets.QGroupBox("Operate")
operategrid = QtWidgets.QGridLayout(operate_groupbox)
rotationgrid.addWidget(self.translatebtn, 7, 0)
rotationgrid.addWidget(self.flipbtn, 8, 0)
self.x_range = QtWidgets.QLineEdit("-3,3")
rotationgrid.addWidget(QtWidgets.QLabel("x-Range (Px)"), 9, 0)
rotationgrid.addWidget(self.x_range, 9, 1)
self.y_range = QtWidgets.QLineEdit("-3,3")
rotationgrid.addWidget(QtWidgets.QLabel("y-Range (Px)"), 10, 0)
rotationgrid.addWidget(self.y_range, 10, 1)
self.z_range = QtWidgets.QLineEdit("-1000,1000")
rotationgrid.addWidget(QtWidgets.QLabel("z-Range (nm)"), 11, 0)
rotationgrid.addWidget(self.z_range, 11, 1)
self.z_range.textChanged.connect(self.adjust_z)
self.x_range.textChanged.connect(self.adjust_xy)
self.y_range.textChanged.connect(self.adjust_xy)
operategrid.addWidget(self.alignxbtn, 0, 1)
operategrid.addWidget(self.alignybtn, 1, 1)
operategrid.addWidget(self.alignzzbtn, 2, 1)
operategrid.addWidget(self.alignzybtn, 3, 1)
operategrid.addWidget(self.translatexbtn, 0, 0)
operategrid.addWidget(self.translateybtn, 1, 0)
operategrid.addWidget(self.translatezbtn, 2, 0)
operategrid.addWidget(self.rotatexy_convbtn, 4, 0)
operategrid.addWidget(self.scorebtn, 4, 1)
self.rotatexy_convbtn.clicked.connect(self.rotatexy_convolution)
self.alignxbtn.clicked.connect(self.align_x)
self.alignybtn.clicked.connect(self.align_y)
self.alignzzbtn.clicked.connect(self.align_zz)
self.alignzybtn.clicked.connect(self.align_zy)
self.translatexbtn.clicked.connect(self.translate_x)
self.translateybtn.clicked.connect(self.translate_y)
self.translatezbtn.clicked.connect(self.translate_z)
self.scorebtn.clicked.connect(self.calculate_score)
buttongrid.addWidget(operate_groupbox, 2, 0)
self.contrastEdit = QtWidgets.QDoubleSpinBox()
self.contrastEdit.setDecimals(1)
self.contrastEdit.setRange(0, 10)
self.contrastEdit.setValue(0.5)
self.contrastEdit.setSingleStep(0.1)
self.contrastEdit.valueChanged.connect(self.updateLayout)
self.grid = QtWidgets.QGridLayout()
self.grid.addWidget(display_groupbox, 0, 0, 2, 1)
self.grid.addWidget(button_groupbox, 0, 1, 1, 1)
contrast_groupbox = QtWidgets.QGroupBox("Contrast")
contrastgrid = QtWidgets.QGridLayout(contrast_groupbox)
contrastgrid.addWidget(self.contrastEdit)
buttongrid.addWidget(contrast_groupbox)
MODEL_X_DEFAULT = "0,20,40,60,0,20,40,60,0,20,40,60"
MODEL_Y_DEFAULT = "0,20,40,0,20,40,0,20,40,0,20,40"
MODEL_Z_DEFAULT = "0,0,0,0,0,0,0,0,0,0,0,0"
self.modelchk = QtWidgets.QCheckBox("Use Model")
self.model_x = QtWidgets.QLineEdit(MODEL_X_DEFAULT)
self.model_y = QtWidgets.QLineEdit(MODEL_Y_DEFAULT)
self.model_z = QtWidgets.QLineEdit(MODEL_Z_DEFAULT)
self.model_preview_btn = QtWidgets.QPushButton("Preview")
self.model_preview_btn.clicked.connect(self.model_preview)
self.modelblurEdit = QtWidgets.QDoubleSpinBox()
self.modelblurEdit.setDecimals(1)
self.modelblurEdit.setRange(0, 10)
self.modelblurEdit.setValue(0.5)
self.modelblurEdit.setSingleStep(0.1)
self.pixelsizeEdit = QtWidgets.QSpinBox()
self.pixelsizeEdit.setRange(1, 999)
self.pixelsizeEdit.setValue(130)
model_groupbox = QtWidgets.QGroupBox("Model")
modelgrid = QtWidgets.QGridLayout(model_groupbox)
modelgrid.addWidget(self.modelchk, 0, 0)
modelgrid.addWidget(QtWidgets.QLabel("X-Coordinates"), 1, 0)
modelgrid.addWidget(self.model_x, 1, 1)
modelgrid.addWidget(QtWidgets.QLabel("Y-Coordinates"), 2, 0)
modelgrid.addWidget(self.model_y, 2, 1)
modelgrid.addWidget(QtWidgets.QLabel("Z-Coordinates"), 3, 0)
modelgrid.addWidget(self.model_z, 3, 1)
modelgrid.addWidget(QtWidgets.QLabel("Blur:"), 4, 0)
modelgrid.addWidget(self.modelblurEdit, 4, 1)
modelgrid.addWidget(QtWidgets.QLabel("Pixelsize:"), 5, 0)
modelgrid.addWidget(self.pixelsizeEdit, 5, 1)
modelgrid.addWidget(self.model_preview_btn, 6, 0)
modelgrid.addWidget(self.modelchk, 6, 1)
buttongrid.addWidget(model_groupbox)
mainWidget = QtWidgets.QWidget()
mainWidget.setLayout(self.grid)
self.setCentralWidget(mainWidget)
self.status_bar.showMessage("Average3 ready.")
def open(self):
path, exe = QtWidgets.QFileDialog.getOpenFileName(
self, "Open localizations", filter="*.hdf5"
)
if path:
self.add(path)
def save(self, path):
n_channels = len(self.locs)
for i in range(n_channels):
cx = self.infos[i][0]["Width"] / 2
cy = self.infos[i][0]["Height"] / 2
out_locs = self.locs[i].copy()
out_locs.x += cx
out_locs.y += cy
info = self.infos[i] + [{"Generated by": "Picasso Average3"}]
if not self.z_state[i]:
out_locs = lib.remove_from_rec(out_locs, "z")
out_path = os.path.splitext(self.locs_paths[i])[0] + "_avg3.hdf5"
path, exe = QtWidgets.QFileDialog.getSaveFileName(
self, "Save localizations", out_path, filter="*.hdf5"
)
io.save_locs(path, out_locs, info)
def dragEnterEvent(self, event):
if event.mimeData().hasUrls():
event.accept()
else:
event.ignore()
def dropEvent(self, event):
urls = event.mimeData().urls()
path = urls[0].toLocalFile()
ext = os.path.splitext(path)[1].lower()
if ext == ".hdf5":
print("Opening {} ..".format(path))
self.add(path)
def add(self, path, rendermode=True):
try:
locs, info = io.load_locs(path, qt_parent=self)
except io.NoMetadataFileError:
return
if len(self.locs) == 0:
self.pixelsize = 0
if not hasattr(locs, "group"):
msgBox = QtWidgets.QMessageBox(self)
msgBox.setWindowTitle("Error")
msgBox.setText(
("Datafile does not contain group information."
" Please load file with picked localizations.")
)
msgBox.exec_()
else:
locs = lib.ensure_sanity(locs, info)
if not hasattr(locs, "z"):
locs = lib.append_to_rec(locs, locs.x.copy(), "z")
self.pixelsize = 1
has_z = False
else:
has_z = True
if self.pixelsize == 0:
pixelsize, ok = QtWidgets.QInputDialog.getInt(
self,
"Pixelsize Dialog",
"Please enter the pixelsize in nm",
130,
)
if ok:
self.pixelsize = pixelsize
else:
self.pixelsize = 130
self.locs.append(locs)
self.z_state.append(has_z)
self.infos.append(info)
self.locs_paths.append(path)
self.index_blocks.append(None)
self._drift.append(None)
self.dataset_dialog.add_entry(path)
self.dataset_dialog.checks[-1].stateChanged.connect(
self.updateLayout
)
cx = self.infos[-1][0]["Width"] / 2
cy = self.infos[-1][0]["Height"] / 2
self.locs[-1].x -= cx
self.locs[-1].y -= cy
if len(self.locs) == 1:
self.median_lp = np.mean(
[np.median(locs.lpx), np.median(locs.lpy)]
)
if hasattr(locs, "group"):
groups = np.unique(locs.group)
groupcopy = locs.group.copy()
for i in range(len(groups)):
groupcopy[locs.group == groups[i]] = i
np.random.shuffle(groups)
groups %= N_GROUP_COLORS
self.group_color = groups[groupcopy]
if render:
self.fit_in_view(autoscale=True)
else:
if render:
self.update_scene()
self.oversampling = 1
if len(self.locs) == 1:
self.t_min = np.min([np.min(locs.x), np.min(locs.y)])
self.t_max = np.max([np.max(locs.x), np.max(locs.y)])
self.z_min = np.min(locs.z)
self.z_max = np.max(locs.z)
else:
self.t_min = np.min(
[np.min(locs.x), np.min(locs.y), self.t_min]
)
self.t_max = np.max(
[np.max(locs.x), np.max(locs.y), self.t_max]
)
self.z_min = np.min([np.min(locs.z), self.z_min])
self.z_max = np.min([np.max(locs.z), self.z_max])
if len(self.locs) == 1:
print("Dataset loaded from {}.".format(path))
else:
print(
("Dataset loaded from {},"
" Total number of datasets {}.").format(
path, len(self.locs)
)
)
# CREATE GROUP INDEX
if hasattr(locs, "group"):
groups = np.unique(locs.group)
n_groups = len(groups)
n_locs = len(locs)
group_index = scipy.sparse.lil_matrix(
(n_groups, n_locs), dtype=np.bool
)
progress = lib.ProgressDialog(
"Creating group index", 0, len(groups), self
)
progress.set_value(0)
for i, group in enumerate(groups):
index = np.where(locs.group == group)[0]
group_index[i, index] = True
progress.set_value(i + 1)
self.group_index.append(group_index)
self.n_groups = n_groups
os.chdir(os.path.dirname(path))
self.calculate_radii()
self.oversampling = 4
self.updateLayout()
def updateLayout(self):
if len(self.locs) > 0:
pixmap1, pixmap2, pixmap3 = self.hist_multi_channel(self.locs)
self.viewxy.setPixmap(pixmap1)
self.viewxz.setPixmap(pixmap2)
self.viewyz.setPixmap(pixmap3)
def centerofmass_all(self):
# Align all by center of mass
n_channels = len(self.locs)
out_locs_x = []
out_locs_y = []
out_locs_z = []
for j in range(n_channels):
sel_locs_x = []
sel_locs_y = []
sel_locs_z = []
# stack arrays
sel_locs_x = self.locs[j].x
sel_locs_y = self.locs[j].y
sel_locs_z = self.locs[j].z
out_locs_x.append(sel_locs_x)
out_locs_y.append(sel_locs_y)
out_locs_z.append(sel_locs_z)
out_locs_x = stack_arrays(out_locs_x, asrecarray=True, usemask=False)
out_locs_y = stack_arrays(out_locs_y, asrecarray=True, usemask=False)
out_locs_z = stack_arrays(out_locs_z, asrecarray=True, usemask=False)
mean_x = np.mean(out_locs_x)
mean_y = np.mean(out_locs_y)
mean_z = np.mean(out_locs_z)
for j in range(n_channels):
self.locs[j].x -= mean_x
self.locs[j].y -= mean_y
self.locs[j].z -= mean_z
def calculate_radii(self):
# CALCULATE PROPER R VALUES
n_channels = len(self.locs)
self.r = 0
self.r_z = 0
for j in range(n_channels):
self.r = np.max(
[
3
* np.sqrt(
np.mean(self.locs[j].x ** 2 + self.locs[j].y ** 2)
),
self.r,
]
)
self.r_z = np.max(
[5 * np.sqrt(np.mean(self.locs[j].z ** 2)), self.r_z]
)
self.t_min = -self.r
self.t_max = self.r
self.z_min = -self.r_z
self.z_max = self.r_z
self.z_min_load = self.z_min.copy()
self.z_max_load = self.z_max.copy()
def centerofmass(self):
print("Aligning by center of mass.. ", end="", flush=True)
n_groups = self.n_groups
n_channels = len(self.locs)
progress = lib.ProgressDialog(
"Aligning by center of mass", 0, n_groups, self
)
progress.set_value(0)
for i in range(n_groups):
out_locs_x = []
out_locs_y = []
out_locs_z = []
for j in range(n_channels):
sel_locs_x = []
sel_locs_y = []
sel_locs_z = []
index = self.group_index[j][i, :].nonzero()[1]
# stack arrays
sel_locs_x = self.locs[j].x[index]
sel_locs_y = self.locs[j].y[index]
sel_locs_z = self.locs[j].z[index]
out_locs_x.append(sel_locs_x)
out_locs_y.append(sel_locs_y)
out_locs_z.append(sel_locs_z)
progress.set_value(i + 1)
out_locs_x = stack_arrays(
out_locs_x, asrecarray=True, usemask=False
)
out_locs_y = stack_arrays(
out_locs_y, asrecarray=True, usemask=False
)
out_locs_z = stack_arrays(
out_locs_z, asrecarray=True, usemask=False
)
mean_x = np.mean(out_locs_x)
mean_y = | np.mean(out_locs_y) | numpy.mean |
'''
Usage 1: python3 split_and_run.py --dataset [dataset name] --num_split [# of split] --metric [distance measure] --num_leaves [num_leaves] --num_search [num_leaves_to_search] --coarse_training_size [coarse traing sample size] --fine_training_size [fine training sample size] --threshold [threshold] --reorder [reorder size] [--split] [--eval_split]
Usage 2: python3 split_and_run.py --dataset [dataset name] --groundtruth --metric [distance measure]
'''
import sys
import numpy as np
import time
import argparse
import os
import h5py
import math
parser = argparse.ArgumentParser(description='Options')
parser.add_argument('--program', type=str, help='scann, faiss ...')
parser.add_argument('--dataset', type=str, default=None, help='sift1b, glove ...')
parser.add_argument('--num_split', type=int, default=-1, help='# of splits')
parser.add_argument('--metric', type=str, default=None, help='dot_product, squared_l2')
## Common algorithm parameters
parser.add_argument('--L', type=int, default=-1, help='# of coarse codewords')
parser.add_argument('--w', type=int, default=-1, help='# of clusters to search')
parser.add_argument('--m', type=int, default=-1, help='# of dimension chunks')
parser.add_argument('--batch', type=int, default=1, help='query batch size')
parser.add_argument('--csize', type=int, default=10000, help='query size in fast scan cache')
## ScaNN parameters
parser.add_argument('--coarse_training_size', type=int, default=250000, help='coarse training sample size')
parser.add_argument('--fine_training_size', type=int, default=100000, help='fine training sample size')
parser.add_argument('--threshold', type=float, default=0.2, help='anisotropic_quantization_threshold')
parser.add_argument('--reorder', type=int, default=-1, help='reorder size')
## Faiss parameters
parser.add_argument('--k_star', type=int, default=-1, help='# of a single finegrained codewords')
parser.add_argument('--is_gpu', action='store_true')
parser.add_argument('--opq', type=int, default=-1, help='new desired dimension after applying OPQ')
parser.add_argument('--sq', type=int, default=-1, help='desired amount of bits per component after SQ')
parser.add_argument('--flat', type=int, default=-1, help='1 if you want to perform exhaustive search')
## Annoy parameters
parser.add_argument('--n_trees', type=int, default=-1, help='# of trees')
## ScaNN & Annoy common parameters
parser.add_argument('--num_search', type=int, default=-1, help='# of searching leaves for ScaNN, # of searching datapoints for Annoy')
parser.add_argument('--topk', type=int, default=-1, help='# of final result')
## Run options
parser.add_argument('--split', action='store_true')
parser.add_argument('--eval_split', action='store_true')
parser.add_argument('--groundtruth', action='store_true')
parser.add_argument('--sweep', action='store_true')
args = parser.parse_args()
assert args.dataset != None and args.topk <= 1000
if args.split != True:
assert args.metric == "squared_l2" or args.metric == "dot_product" or args.metric=="angular"
if args.eval_split or args.sweep:
assert args.program!=None and args.metric!=None and args.num_split!=-1 and args.topk!=-1
if args.groundtruth:
import ctypes
assert args.metric!=None
if args.program=='scann':
import scann
assert args.is_gpu == False and (args.topk <= args.reorder if args.reorder!=-1 else True)
if args.sweep == False:
assert args.L!=-1 and args.w!=-1 and args.topk!=-1 and args.k_star == -1 and args.m!=-1
assert args.topk!=-1
elif args.program == "faiss":
#if os.environ.get('LD_PRELOAD') == None:
# assert False, "Please set LD_PRELOAD environment path and retry"
# export LD_PRELOAD=/opt/intel/mkl/lib/intel64/libmkl_def.so:/opt/intel/mkl/lib/intel64/libmkl_avx2.so:/opt/intel/mkl/lib/intel64/libmkl_core.so:/opt/intel/mkl/lib/intel64/libmkl_intel_lp64.so:/opt/intel/mkl/lib/intel64/libmkl_intel_thread.so:/opt/intel/lib/intel64_lin/libiomp5.so
from runfaiss import build_faiss, faiss_search, check_cached, faiss_search_flat
import math
if args.sweep == False:
assert args.L!=-1 and args.k_star!=-1 and args.w!=-1 and args.m!=-1
elif args.program == "annoy":
import annoy
if args.batch > 1:
from multiprocessing.pool import ThreadPool
assert args.topk!=-1 and args.is_gpu==False and (args.num_search!=-1 and args.n_trees!=-1 if args.sweep!=True else True)
def compute_recall(neighbors, true_neighbors):
total = 0
for gt_row, row in zip(true_neighbors, neighbors):
# print("SHAPE =", np.shape(np.intersect1d(gt_row, row)))
total += np.intersect1d(gt_row, row).shape[0]
return total / true_neighbors.size
def compute_more_recalls(neighbors, true_neighbors, target, base):
total = 0
trimmed_neighbors = neighbors[:,:base]
trimmed_gt = true_neighbors[:,:target]
num_queries, _ = np.shape(trimmed_gt)
# print("trimmed_neighbors shape =", np.shape(trimmed_neighbors))
# print("trimmed_gt shape =", np.shape(trimmed_gt))
for i in range(num_queries):
curr_neighbors_row = trimmed_neighbors[i]
curr_gt_row = trimmed_gt[i]
for curr_gt_elem in curr_gt_row:
if curr_gt_elem in curr_neighbors_row:
total += 1
return total / trimmed_gt.size
def print_more_recalls(final_neighbors, gt):
print("final_neighbors :", final_neighbors.shape)
print("gt :", gt.shape)
top1_10 = compute_more_recalls(final_neighbors, gt, 1, 10)
top1_100 = compute_more_recalls(final_neighbors, gt, 1, 100)
top10_100 = compute_more_recalls(final_neighbors, gt, 10, 100)
top1_1000 = compute_more_recalls(final_neighbors, gt, 1, 1000)
top10_1000 = compute_more_recalls(final_neighbors, gt, 10, 1000)
top100_1000 = compute_more_recalls(final_neighbors, gt, 100, 1000)
print("Recall 1@10:", top1_10)
print("Recall 1@100:", top1_100)
print("Recall 10@100:", top10_100)
print("Recall 1@1000:", top1_1000)
print("Recall 10@1000:", top10_1000)
print("Recall 100@1000:", top100_1000)
return top1_10, top1_100, top10_100, top1_1000, top10_1000, top100_1000
def ivecs_read(fname):
a = np.fromfile(fname, dtype='int32')
d = a[0]
return a.reshape(-1, d + 1)[:, 1:]
def ivecs_write(fname, m):
n, d = m.shape
dimension_arr = np.zeros((n, 1), dtype=np.int32)
dimension_arr[:, 0] = d
m = np.append(dimension_arr, m, axis=1)
m.tofile(fname)
def bvecs_mmap(fname, offset_=None, shape_=None):
if offset_!=None and shape_!=None:
x = np.memmap(fname, dtype=np.uint8, mode='r', offset=offset_*132, shape=(shape_*132))
else:
x = np.memmap(fname, dtype=np.uint8, mode='r')
d = x[:4].view('int32')[0]
return x.reshape(-1, d + 4)[:, 4:]
def bvecs_write(fname, m):
n, d = m.shape
dimension_arr = np.zeros((n, 4), dtype=np.uint8)
dimension_arr[:, 0] = d
m = np.append(dimension_arr, m, axis=1)
m.tofile(fname)
def bvecs_read(fname):
b = np.fromfile(fname, dtype=np.uint8)
d = b[:4].view('int32')[0]
return b.reshape(-1, d+4)[:, 4:]
def mmap_fvecs(fname, offset_=None, shape_=None):
if offset_!=None and shape_!=None:
x = np.memmap(fname, dtype='int32', mode='r', offset=(offset_*(D+1)*4), shape=(shape_*(D+1)))
else:
x = np.memmap(fname, dtype='int32', mode='r')
d = x[0]
return x.reshape(-1, d + 1)[:, 1:].view(np.float32)
# Use for synthetic billion dataset
def mmap_fvecs2(fname, offset_=None, shape_=None):
if offset_!=None and shape_!=None:
x = np.memmap(fname, dtype='float16', mode='r', offset=(offset_*(D+1)*2), shape=(shape_*(D+1)))
else:
x = np.memmap(fname, dtype='float16', mode='r')
d = int(x[0])
return x.reshape(-1, d + 1)[:, 1:].view(np.float16)
def fvecs_write(fname, m):
m = m.astype('float32')
n, d = m.shape
m1 = np.empty((n, d + 1), dtype='int32')
m1[:, 0] = d
m1[:, 1:] = m.view('int32')
m1.tofile(fname)
def txt_to_fvecs(fname):
txt_arr = np.loadtxt(fname)
if "_clognormal" in fname:
if "query" in fname:
fvecs_write(dataset_basedir + "clognormal1m_query.fvecs", txt_arr)
else:
fvecs_write(dataset_basedir + "clognormal1m_base.fvecs", txt_arr)
elif "_cnormal" in fname:
if "query" in fname:
fvecs_write(dataset_basedir + "cnormal1m_query.fvecs", txt_arr)
else:
fvecs_write(dataset_basedir + "cnormal1m_base.fvecs", txt_arr)
elif "_lognormal" in fname:
if "query" in fname:
fvecs_write(dataset_basedir + "lognormal1m_query.fvecs", txt_arr)
else:
fvecs_write(dataset_basedir + "lognormal1m_base.fvecs", txt_arr)
elif "_normal" in fname:
if "query" in fname:
fvecs_write(dataset_basedir + "normal1m_query.fvecs", txt_arr)
else:
fvecs_write(dataset_basedir + "normal1m_base.fvecs", txt_arr)
def read_fbin(filename, start_idx=0, chunk_size=None):
""" Read *.fbin file that contains float32 vectors
Args:
:param filename (str): path to *.fbin file
:param start_idx (int): start reading vectors from this index
:param chunk_size (int): number of vectors to read.
If None, read all vectors
Returns:
Array of float32 vectors (numpy.ndarray)
"""
with open(filename, "rb") as f:
nvecs, dim = np.fromfile(f, count=2, dtype=np.int32)
nvecs = (nvecs - start_idx) if chunk_size is None else chunk_size
arr = np.fromfile(f, count=nvecs * dim, dtype=np.float32,
offset=start_idx * 4 * dim)
return arr.reshape(nvecs, dim)
def read_ibin(filename, start_idx=0, chunk_size=None):
""" Read *.ibin file that contains int32 vectors
Args:
:param filename (str): path to *.ibin file
:param start_idx (int): start reading vectors from this index
:param chunk_size (int): number of vectors to read.
If None, read all vectors
Returns:
Array of int32 vectors (numpy.ndarray)
"""
with open(filename, "rb") as f:
nvecs, dim = np.fromfile(f, count=2, dtype=np.int32)
nvecs = (nvecs - start_idx) if chunk_size is None else chunk_size
arr = np.fromfile(f, count=nvecs * dim, dtype=np.int32,
offset=start_idx * 4 * dim)
return arr.reshape(nvecs, dim)
def write_fbin(filename, vecs):
""" Write an array of float32 vectors to *.fbin file
Args:s
:param filename (str): path to *.fbin file
:param vecs (numpy.ndarray): array of float32 vectors to write
"""
assert len(vecs.shape) == 2, "Input array must have 2 dimensions"
with open(filename, "wb") as f:
nvecs, dim = vecs.shape
f.write(struct.pack('<i', nvecs))
f.write(struct.pack('<i', dim))
vecs.astype('float32').flatten().tofile(f)
def write_ibin(filename, vecs):
""" Write an array of int32 vectors to *.ibin file
Args:
:param filename (str): path to *.ibin file
:param vecs (numpy.ndarray): array of int32 vectors to write
"""
assert len(vecs.shape) == 2, "Input array must have 2 dimensions"
with open(filename, "wb") as f:
nvecs, dim = vecs.shape
f.write(struct.pack('<i', nvecs))
f.write(struct.pack('<i', dim))
vecs.astype('int32').flatten().tofile(f)
def read_data(dataset_path, offset_=None, shape_=None, base=True):
if "sift1m" in args.dataset:
file = dataset_path + "sift_base.fvecs" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif "deep1m" in args.dataset:
file = dataset_path + "deep1m_base.fvecs" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif "deepm96" in args.dataset:
file = dataset_path + "deepm96_base.fvecs" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif "test" in args.dataset:
file = dataset_path + "test.fvecs" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif args.dataset == "clognormal1m":
file = dataset_path + "clognormal1m_base.fvecs" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif args.dataset == "cnormal1m":
file = dataset_path + "cnormal1m_base.fvecs" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif args.dataset == "lognormal1m":
file = dataset_path + "lognormal1m_base.fvecs" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif args.dataset == "normal1m":
file = dataset_path + "normal1m_base.fvecs" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif args.dataset == "clognormal1b":
file = dataset_path + "1000000000_128_clognormal.txt" if base else dataset_path
return mmap_fvecs2(file, offset_=offset_, shape_=shape_) if base else mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif args.dataset == "cnormal1b":
file = dataset_path + "1000000000_128_cnormal.txt" if base else dataset_path
return mmap_fvecs2(file, offset_=offset_, shape_=shape_) if base else mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif args.dataset == "lognormal1b":
file = dataset_path + "1000000000_128_lognormal.txt" if base else dataset_path
return mmap_fvecs2(file, offset_=offset_, shape_=shape_) if base else mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif args.dataset == "normal1b":
file = dataset_path + "1000000000_128_normal.txt" if base else dataset_path
return mmap_fvecs2(file, offset_=offset_, shape_=shape_) if base else mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif "music1m" in args.dataset:
# file = dataset_path + "database_music100.bin" if base else dataset_path
# return np.fromfile(file, dtype = np.float32).reshape(N, D)
file = dataset_path + "split_data/music1m_1_0" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif "gist" in args.dataset:
file = dataset_path + "gist_base.fvecs" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif "sift1b" in args.dataset:
file = dataset_path+"bigann_base.bvecs" if base else dataset_path
return bvecs_mmap(file, offset_=offset_, shape_=shape_)
elif "deep1b" in args.dataset:
file = dataset_path+"deep1B_base.fvecs" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif "tti1m" in args.dataset:
file = dataset_path+"/split_data/tti1m_1_0" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif "tti1b" in args.dataset:
file = dataset_path+"base.1B.fbin" if base else dataset_path
return mmap_fvecs(file, offset_=offset_, shape_=shape_)
elif "glove" in args.dataset:
file = dataset_path+"glove-100-angular.hdf5" if base else dataset_path
if base:
dataset = h5py.File(file, "r")
dataset = np.array(dataset['train'], dtype='float32')
if args.metric == "dot_product":
dataset = dataset / np.linalg.norm(dataset, axis=1)[:, np.newaxis]
if offset_!=None and shape_!=None:
return dataset[offset_:offset_+shape_]
else:
return dataset
else:
dataset = h5py.File(dataset_path, "r")
return | np.array(dataset['dataset'], dtype='float32') | numpy.array |
# -*- coding: utf-8 -*-
"""Proximity Forest time series classifier
a decision tree forest which uses distance measures to partition data.
<NAME> and <NAME>, <NAME>, <NAME>, <NAME>, <NAME>,
<NAME> and <NAME>
Proximity Forest: an effective and scalable distance-based classifier for
time series,
Data Mining and Knowledge Discovery, 33(3): 607-635, 2019
"""
# linkedin.com/goastler; github.com/goastler
__author__ = ["<NAME>"]
__all__ = ["ProximityForest", "_CachedTransformer", "ProximityStump", "ProximityTree"]
import numpy as np
import pandas as pd
from joblib import Parallel
from joblib import delayed
from scipy import stats
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import normalize
from sklearn.utils import check_random_state
from sktime.classification.base import BaseClassifier
from sktime.distances.elastic_cython import dtw_distance
from sktime.distances.elastic_cython import erp_distance
from sktime.distances.elastic_cython import lcss_distance
from sktime.distances.elastic_cython import msm_distance
from sktime.distances.elastic_cython import twe_distance
from sktime.distances.elastic_cython import wdtw_distance
from sktime.transformers.base import _PanelToPanelTransformer
from sktime.transformers.panel.summarize import DerivativeSlopeTransformer
from sktime.utils import comparison
from sktime.utils import dataset_properties
from sktime.utils.data_container import from_nested_to_2d_array
from sktime.utils.validation.panel import check_X
from sktime.utils.validation.panel import check_X_y
# todo unit tests / sort out current unit tests
# todo logging package rather than print to screen
# todo get params avoid func pointer - use name
# todo set params use func name or func pointer
# todo constructor accept str name func / pointer
# todo duck-type functions
class _CachedTransformer(_PanelToPanelTransformer):
"""Transformer container that transforms data and adds the transformed
version to a cache.
If the transformation is called again on already seen data the data is
fetched
from the cache rather than performing the expensive transformation.
Parameters
----------
transformer : the transformer to transform uncached data
Attributes
----------
cache : location to store transforms seen before for fast look up
"""
_required_parameters = ["transformer"]
def __init__(self, transformer):
self.cache = {}
self.transformer = transformer
super(_CachedTransformer, self).__init__()
def clear(self):
"""
clear the cache
"""
self.cache = {}
def transform(self, X, y=None):
"""
Fit transformer, creating a cache for transformation.
Parameters
----------
X : pandas DataFrame of shape [n_instances, n_features]
Input data
y : pandas Series, shape (n_instances), optional
Targets for supervised learning.
Returns
-------
cached_instances.
"""
# for each instance, get transformed instance from cache or
# transform and add to cache
cached_instances = {}
uncached_indices = []
for index in X.index.values:
try:
cached_instances[index] = self.cache[index]
except Exception:
uncached_indices.append(index)
if len(uncached_indices) > 0:
uncached_instances = X.loc[uncached_indices, :]
transformed_uncached_instances = self.transformer.fit_transform(
uncached_instances
)
transformed_uncached_instances.index = uncached_instances.index
transformed_uncached_instances = transformed_uncached_instances.to_dict(
"index"
)
self.cache.update(transformed_uncached_instances)
cached_instances.update(transformed_uncached_instances)
cached_instances = pd.DataFrame.from_dict(cached_instances, orient="index")
return cached_instances
def __str__(self):
return self.transformer.__str__()
def _derivative_distance(distance_measure, transformer):
"""
take derivative before conducting distance measure
:param distance_measure: the distance measure to use
:param transformer: the transformer to use
:return: a distance measure function with built in transformation
"""
def distance(instance_a, instance_b, **params):
df = pd.DataFrame([instance_a, instance_b])
df = transformer.transform(X=df)
instance_a = df.iloc[0, :]
instance_b = df.iloc[1, :]
return distance_measure(instance_a, instance_b, **params)
return distance
def distance_predefined_params(distance_measure, **params):
"""
conduct distance measurement with a predefined set of parameters
:param distance_measure: the distance measure to use
:param params: the parameters to use in the distance measure
:return: a distance measure with no parameters
"""
def distance(instance_a, instance_b):
return distance_measure(instance_a, instance_b, **params)
return distance
def cython_wrapper(distance_measure):
"""
wrap a distance measure in cython conversion (to 1 column per dimension
format)
:param distance_measure: distance measure to wrap
:return: a distance measure which automatically formats data for cython
distance measures
"""
def distance(instance_a, instance_b, **params):
# find distance
instance_a = from_nested_to_2d_array(
instance_a, return_numpy=True
) # todo use specific
# dimension rather than whole
# thing?
instance_b = from_nested_to_2d_array(
instance_b, return_numpy=True
) # todo use specific
# dimension rather than whole thing?
instance_a = np.transpose(instance_a)
instance_b = np.transpose(instance_b)
return distance_measure(instance_a, instance_b, **params)
return distance
def pure(y):
"""
test whether a set of class labels are pure (i.e. all the same)
----
Parameters
----
y : 1d array like
array of class labels
----
Returns
----
result : boolean
whether the set of class labels is pure
"""
# get unique class labels
unique_class_labels = np.unique(np.array(y))
# if more than 1 unique then not pure
return len(unique_class_labels) <= 1
def gini_gain(y, y_subs):
"""
get gini score of a split, i.e. the gain from parent to children
----
Parameters
----
y : 1d array like
array of class labels at parent
y_subs : list of 1d array like
list of array of class labels, one array per child
----
Returns
----
score : float
gini score of the split from parent class labels to children. Note a
higher score means better gain,
i.e. a better split
"""
y = np.array(y)
# find number of instances overall
parent_n_instances = y.shape[0]
# if parent has no instances then is pure
if parent_n_instances == 0:
for child in y_subs:
if len(child) > 0:
raise ValueError("children populated but parent empty")
return 0.5
# find gini for parent node
score = gini(y)
# sum the children's gini scores
for index in range(len(y_subs)):
child_class_labels = y_subs[index]
# ignore empty children
if len(child_class_labels) > 0:
# find gini score for this child
child_score = gini(child_class_labels)
# weight score by proportion of instances at child compared to
# parent
child_size = len(child_class_labels)
child_score *= child_size / parent_n_instances
# add to cumulative sum
score -= child_score
return score
def gini(y):
"""
get gini score at a specific node
----
Parameters
----
y : 1d numpy array
array of class labels
----
Returns
----
score : float
gini score for the set of class labels (i.e. how pure they are). A
larger score means more impurity. Zero means
pure.
"""
y = | np.array(y) | numpy.array |
from hazel.chromosphere import Hazel_atmosphere
from hazel.photosphere import SIR_atmosphere
from hazel.parametric import Parametric_atmosphere
from hazel.stray import Straylight_atmosphere
from hazel.configuration import Configuration
from hazel.io import Generic_output_file
from collections import OrderedDict
from hazel.codes import hazel_code, sir_code
from hazel.spectrum import Spectrum
from hazel.transforms import transformed_to_physical, physical_to_transformed, jacobian_transformation
import hazel.util
import numpy as np
import copy
import os
from pathlib import Path
import scipy.stats
import scipy.special
import scipy.signal
import scipy.linalg
import scipy.optimize
import warnings
import logging
import sys
__all__ = ['Model']
class Model(object):
def __init__(self, config=None, working_mode='synthesis', verbose=0, debug=False, rank=0, randomization=None, root=''):
np.random.seed(123)
if (rank != 0):
return
self.photospheres = []
self.chromospheres = []
self.chromospheres_order = []
self.atmospheres = {}
self.order_atmospheres = []
self.straylight = []
self.parametric = []
self.spectrum = []
self.configuration = None
self.n_cycles = 1
self.spectrum = {}
self.topologies = []
self.straylights = []
self.working_mode = working_mode
self.pixel = 0
self.debug = debug
self.use_analytical_RF_if_possible = False
self.nlte_available = False
self.use_nlte = False
self.root = root
self.epsilon = 1e-2
self.svd_tolerance = 1e-8
self.step_limiter_inversion = 1.0
self.backtracking = 'brent'
self.verbose = verbose
self.logger = logging.getLogger("model")
self.logger.setLevel(logging.DEBUG)
self.logger.handlers = []
ch = logging.StreamHandler()
# formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
formatter = logging.Formatter('%(asctime)s - %(message)s')
ch.setFormatter(formatter)
self.logger.addHandler(ch)
# Set randomization
if (randomization is None):
self.n_randomization = 1
else:
self.n_randomization = randomization
if (self.verbose >= 1):
self.logger.info('Hazel2 v1.0')
if ('torch' in sys.modules and 'torch_geometric' in sys.modules):
if (self.verbose >= 1):
self.logger.info('PyTorch and PyTorch Geometric found. NLTE for Ca II is available')
self.nlte_available = True
if (config is not None):
if (self.verbose >= 1):
self.logger.info('Using configuration from file : {0}'.format(config))
self.configuration = Configuration(config)
self.use_configuration(self.configuration.config_dict)
# Initialize pyhazel
hazel_code._init()
def __getstate__(self):
d = self.__dict__.copy()
if 'logger' in d:
d['logger'] = d['logger'].name
return d
def __setstate__(self, d):
if 'logger' in d:
d['logger'] = logging.getLogger(d['logger'])
self.__dict__.update(d)
def __str__(self):
tmp = ''
for l, par in self.__dict__.items():
if (l != 'LINES'):
tmp += '{0}: {1}\n'.format(l, par)
return tmp
def use_configuration(self, config_dict):
"""
Use a configuration file
Parameters
----------
config_dict : dict
Dictionary containing all the options from the configuration file previously read
Returns
-------
None
"""
# Deal with the spectral regions
tmp = config_dict['spectral regions']
# Output file
self.output_file = config_dict['working mode']['output file']
# Backtracking mode
if ('backtracking' in config_dict['working mode']):
self.backtracking = config_dict['working mode']['backtracking']
else:
self.backtracking = 'brent'
if (self.verbose >= 1):
self.logger.info('Backtracking mode : {0}'.format(self.backtracking))
# Working mode
# self.working_mode = config_dict['working mode']['action']
# Add spectral regions
for key, value in config_dict['spectral regions'].items():
self.add_spectral(value)
# Set number of cycles if present
if (self.working_mode == 'inversion'):
if ('number of cycles' in config_dict['working mode']):
if (config_dict['working mode']['number of cycles'] != 'None'):
self.n_cycles = int(config_dict['working mode']['number of cycles'])
if (self.verbose >= 1):
self.logger.info('Using {0} cycles'.format(self.n_cycles))
# Use analytical RFs if possible
if ('analytical rf if possible' in config_dict['working mode']):
if (config_dict['working mode']['analytical rf if possible'] != 'None'):
self.use_analytical_RF_if_possible = hazel.util.tobool(config_dict['working mode']['analytical rf if possible'])
else:
self.use_analytical_RF_if_possible = False
else:
self.use_analytical_RF_if_possible = False
if (self.verbose >= 1):
self.logger.info('Using analytical RFs if possible : {0}'.format(self.use_analytical_RF_if_possible))
# Set number of maximum iterations
if ('maximum iterations' in config_dict['working mode']):
if (config_dict['working mode']['number of cycles'] != 'None'):
self.max_iterations = int(config_dict['working mode']['maximum iterations'])
else:
self.max_iterations = 10
else:
self.max_iterations = 10
if (self.verbose >= 1):
self.logger.info('Using {0} max. iterations'.format(self.max_iterations))
# Randomization
if (self.verbose >= 1):
if (self.n_randomization == 1):
self.logger.info('Not using randomizations')
else:
self.logger.info('Using a maximum of {0} randomizations'.format(self.n_randomization))
# Set number of maximum iterations
if ('relative error' in config_dict['working mode']):
if (config_dict['working mode']['relative error'] != 'None'):
self.relative_error = float(config_dict['working mode']['relative error'])
if (self.verbose >= 1):
self.logger.info('Stopping when relative error is below {0}'.format(self.relative_error))
else:
self.relative_error = 1e-4
else:
self.relative_error = 1e-4
# Save all cycles
if ('save all cycles' not in config_dict['working mode']):
self.save_all_cycles = False
else:
self.save_all_cycles = hazel.util.tobool(config_dict['working mode']['save all cycles'])
if (self.verbose >= 1):
self.logger.info('Saving all cycles : {0}'.format(self.save_all_cycles))
# Deal with the atmospheres
tmp = config_dict['atmospheres']
self.atmospheres = {}
if (self.verbose >= 1):
self.logger.info('Adding atmospheres')
for key, value in tmp.items():
if ('photosphere' in key):
if (self.verbose >=1):
self.logger.info(' - New available photosphere : {0}'.format(value['name']))
self.add_photosphere(value)
if ('chromosphere' in key):
if (self.verbose >= 1):
self.logger.info(' - New available chromosphere : {0}'.format(value['name']))
self.add_chromosphere(value)
if ('parametric' in key):
if (self.verbose >= 1):
self.logger.info(' - New available parametric : {0}'.format(value['name']))
self.add_parametric(value)
if ('straylight' in key):
if (self.verbose >= 1):
self.logger.info(' - New available straylight : {0}'.format(value['name']))
self.add_straylight(value)
self.setup()
def setup(self):
"""
Setup the model for synthesis/inversion. This setup includes adding the topologies, removing unused
atmospheres, reading the number of cycles for the inversion and some sanity checks
Parameters
----------
None
Returns
-------
None
"""
# Adding topologies
if (self.verbose >= 1):
self.logger.info("Adding topologies")
for value in self.topologies:
self.add_topology(value)
# Remove unused atmospheres defined in the configuration file and not in the topology
if (self.verbose >= 1):
self.logger.info("Removing unused atmospheres")
self.remove_unused_atmosphere()
# Calculate indices for atmospheres
index_chromosphere = 1
index_photosphere = 1
self.n_photospheres = 0
self.n_chromospheres = 0
for k, v in self.atmospheres.items():
if (v.type == 'photosphere'):
v.index = index_photosphere
index_photosphere += 1
self.n_photospheres += 1
if (v.type == 'chromosphere'):
v.index = index_chromosphere
index_chromosphere += 1
self.n_chromospheres += 1
# Use analytical RFs if only photospheres are defined
if (self.n_chromospheres == 0 and self.use_analytical_RF_if_possible):
self.use_analytical_RF = True
if (self.verbose >= 1):
self.logger.info('Using analytical RFs : {0}'.format(self.use_analytical_RF))
else:
self.use_analytical_RF = False
# Check that number of pixels is the same for all atmospheric files if in synthesis mode
if (self.working_mode == 'synthesis'):
n_pixels = [v.n_pixel for k, v in self.atmospheres.items()]
all_equal = all(x == n_pixels[0] for x in n_pixels)
if (not all_equal):
for k, v in self.atmospheres.items():
self.logger.info('{0} -> {1}'.format(k, v.n_pixel))
raise Exception("Files with model atmospheres do not contain the same number of pixels")
else:
if (self.verbose >= 1):
self.logger.info('Number of pixels to read : {0}'.format(n_pixels[0]))
self.n_pixels = n_pixels[0]
if (self.working_mode == 'inversion'):
n_pixels = [v.n_pixel for k, v in self.spectrum.items()]
all_equal = all(x == n_pixels[0] for x in n_pixels)
if (not all_equal):
for k, v in self.spectrum.items():
self.logger.info('{0} -> {1}'.format(k, v.n_pixel))
raise Exception("Files with spectral regions do not contain the same number of pixels")
else:
if (self.verbose >= 1):
self.logger.info('Number of pixels to invert : {0}'.format(n_pixels[0]))
self.n_pixels = n_pixels[0]
# Check that the number of pixels from all observations (in case of inversion) is the same
# Check also if they are equal to those of the models
# n_pixels = [v.n_pixel for k, v in self.atmospheres.items()]
# all_equal = all(x == n_pixels[0] for x in n_pixels)
# Check that the number of cycles is the same for all atmospheres (in case of inversion)
if (self.working_mode == 'inversion'):
cycles = []
for k, v in self.atmospheres.items():
for k2, v2 in v.cycles.items():
if (v2 is not None):
cycles.append(len(v2))
all_equal = all(x == cycles[0] for x in cycles)
if (not all_equal):
raise Exception("Number of cycles in the nodes of active atmospheres is not always the same")
else:
if (self.n_cycles is None):
self.n_cycles = cycles[0]
# if (self.working_mode == 'inversion'):
# cycles = []
# for tmp in ['I', 'Q', 'U', 'V']:
# if ( cycles.append
# for k, v in self.atmospheres.items():
# for k2, v2 in v.cycles.items():
# cycles.append(len(v2))
# all_equal = all(x == cycles[0] for x in cycles)
# if (not all_equal):
# raise Exception("Number of cycles in the nodes of active atmospheres is not always the same")
# else:
# if (self.n_cycles is None):
# self.n_cycles = cycles[0]
filename = os.path.join(os.path.dirname(__file__),'data/LINEAS')
ff = open(filename, 'r')
self.LINES = ff.readlines()
ff.close()
self.init_sir()
for k, v in self.spectrum.items():
v.allocate_info_cycles(n_cycles=self.n_cycles)
for k, v in self.atmospheres.items():
v.allocate_info_cycles(n_cycles=self.n_cycles)
# Count total number of free parameters
if (self.working_mode == 'inversion'):
self.n_free_parameters = 0
for k, v in self.atmospheres.items():
for k2, v2 in v.cycles.items():
if (v2 is not None):
self.n_free_parameters += max(hazel.util.onlyint(v2[0:self.n_cycles+1]))
if (self.verbose >= 1):
self.logger.info('Total number of free parameters in all cycles : {0}'.format(self.n_free_parameters))
def open_output(self):
self.output_handler = Generic_output_file(self.output_file)
self.output_handler.open(self)
def close_output(self):
self.output_handler.close()
def write_output(self, randomization=0):
if (self.working_mode == 'synthesis'):
self.flatten_parameters_to_reference(cycle=0)
self.output_handler.write(self, pixel=0, randomization=randomization)
def add_spectral(self, spectral):
"""
Programmatically add a spectral region
Parameters
----------
spectral : dict
Dictionary containing the following data
'Name', 'Wavelength', 'Topology', 'Weights Stokes', 'Wavelength file', 'Wavelength weight file',
'Observations file', 'Mask file'
Returns
-------
None
"""
# Make sure that all keys of the input dictionary are in lower case
# This is irrelevant if a configuration file is used because this has been
# already done
value = hazel.util.lower_dict_keys(spectral)
if (self.verbose >= 1):
self.logger.info('Adding spectral region {0}'.format(value['name']))
if ('wavelength file' not in value):
value['wavelength file'] = None
elif (value['wavelength file'] == 'None'):
value['wavelength file'] = None
if ('wavelength weight file' not in value):
value['wavelength weight file'] = None
elif (value['wavelength weight file'] == 'None'):
value['wavelength weight file'] = None
if ('observations file' not in value):
value['observations file'] = None
elif (value['observations file'] == 'None'):
value['observations file'] = None
if ('stokes weights' not in value):
value['stokes weights'] = None
elif (value['stokes weights'] == 'None'):
value['stokes weights'] = None
if ('mask file' not in value):
value['mask file'] = None
elif (value['mask file'] == 'None'):
value['mask file'] = None
if ('los' not in value):
value['los'] = None
elif (value['los'] == 'None'):
value['los'] = None
for tmp in ['i', 'q', 'u', 'v']:
if ('weights stokes {0}'.format(tmp) not in value):
value['weights stokes {0}'.format(tmp)] = [None]*10
elif (value['weights stokes {0}'.format(tmp)] == 'None'):
value['weights stokes {0}'.format(tmp)] = [None]*10
if ('boundary condition' not in value):
value['boundary condition'] = None
elif (value['boundary condition'] == 'None'):
value['boundary condition'] = None
if ('instrumental profile' not in value):
value['instrumental profile'] = None
elif (value['instrumental profile'] == 'None'):
value['instrumental profile'] = None
# Wavelength file is not present
if (value['wavelength file'] is None):
# If the wavelength is defined
if ('wavelength' in value):
axis = value['wavelength']
wvl = np.linspace(float(axis[0]), float(axis[1]), int(axis[2]))
wvl_lr = None
if (self.verbose >= 1):
self.logger.info(' - Using wavelength axis from {0} to {1} with {2} steps'.format(float(axis[0]), float(axis[1]), int(axis[2])))
else:
raise Exception('Wavelength range is not defined. Please, use "Wavelength" or "Wavelength file"')
else:
# If both observed and synthetic wavelength points are given
if ('wavelength' in value):
axis = value['wavelength']
if (len(axis) != 3):
raise Exception("Wavelength range is not given in the format: lower, upper, steps")
wvl = np.linspace(float(axis[0]), float(axis[1]), int(axis[2]))
if (self.verbose >= 1):
self.logger.info(' - Using wavelength axis from {0} to {1} with {2} steps'.format(float(axis[0]), float(axis[1]), int(axis[2])))
self.logger.info(' - Reading wavelength axis from {0}'.format(value['wavelength file']))
wvl_lr = np.loadtxt(self.root + value['wavelength file'])
else:
if (self.verbose >= 1):
self.logger.info(' - Reading wavelength axis from {0}'.format(value['wavelength file']))
wvl = np.loadtxt(self.root + value['wavelength file'])
wvl_lr = None
if (value['wavelength weight file'] is None):
if (self.verbose >= 1 and self.working_mode == 'inversion'):
self.logger.info(' - Setting all wavelength weights to 1')
weights = np.ones((4,len(wvl)))
else:
if (self.verbose >= 1):
self.logger.info(' - Reading wavelength weights from {0}'.format(value['wavelength weight file']))
weights = np.loadtxt(self.root + value['wavelength weight file'], skiprows=1).T
# Observations file not present
if (value['observations file'] is None):
if (self.working_mode == 'inversion'):
raise Exception("Inversion mode without observations is not allowed.")
obs_file = None
else:
if (self.verbose >= 1):
self.logger.info(' - Using observations from {0}'.format(value['observations file']))
obs_file = value['observations file']
if (value['mask file'] is None):
mask_file = None
if (self.verbose >= 1):
self.logger.info(' - No mask for pixels')
else:
if (self.verbose >= 1):
self.logger.info(' - Using mask from {0}'.format(value['mask file']))
mask_file = value['mask file']
if (value['instrumental profile'] is None):
if (self.verbose >= 1):
self.logger.info(' - No instrumental profile')
else:
if (self.verbose >= 1):
self.logger.info(' - Instrumental profile : {0}'.format(value['instrumental profile']))
# if (value['straylight file'] is None):
# if (self.verbose >= 1):
# self.logger.info(' - Not using straylight')
# stray_file = None
# else:
# if (self.verbose >= 1):
# self.logger.info(' - Using straylight from {0}'.format(value['straylight file']))
# stray_file = value['straylight file']
if (value['los'] is None):
if (self.working_mode == 'synthesis'):
raise Exception("You need to provide the LOS for spectral region {0}".format(value['name']))
los = None
else:
los = np.array(value['los']).astype('float64')
if (self.verbose >= 1):
self.logger.info(' - Using LOS {0}'.format(value['los']))
if (value['boundary condition'] is None):
if (self.verbose >= 1):
self.logger.info(' - Using default boundary conditions [1,0,0,0] in spectral region {0} or read from file. Check carefully!'.format(value['name']))
boundary = np.array([1.0,0.0,0.0,0.0])
self.normalization = 'on-disk'
else:
boundary = np.array(value['boundary condition']).astype('float64')
if (boundary[0] == 0.0):
if (self.verbose >= 1):
self.logger.info(' - Using off-limb normalization (peak intensity)')
if (self.verbose >= 1):
self.logger.info(' - Using boundary condition {0}'.format(value['boundary condition']))
stokes_weights = []
for st in ['i', 'q', 'u', 'v']:
tmp = hazel.util.tofloat(value['weights stokes {0}'.format(st)])
tmp = [i if i is not None else 1.0 for i in tmp]
stokes_weights.append(tmp)
stokes_weights = np.array(stokes_weights)
self.spectrum[value['name']] = Spectrum(wvl=wvl, weights=weights, observed_file=obs_file,
name=value['name'], stokes_weights=stokes_weights, los=los, boundary=boundary, mask_file=mask_file, instrumental_profile=value['instrumental profile'], root=self.root, wvl_lr=wvl_lr)
self.topologies.append(value['topology'])
def add_photosphere(self, atmosphere):
"""
Programmatically add a photosphere
Parameters
----------
atmosphere : dict
Dictionary containing the following data
'Name', 'Spectral region', 'Height', 'Line', 'Wavelength', 'Reference atmospheric model',
'Ranges', 'Nodes'
Returns
-------
None
"""
# Make sure that all keys of the input dictionary are in lower case
# This is irrelevant if a configuration file is used because this has been
# already done
atm = hazel.util.lower_dict_keys(atmosphere)
self.atmospheres[atm['name']] = SIR_atmosphere(working_mode=self.working_mode, name=atm['name'], verbose=self.verbose)
lines = [int(k) for k in list(atm['spectral lines'])]
# If NLTE is available because PyTorch and PyTorch Geom are available
# check whether the line is needed in NLTE or not
if self.nlte_available:
if ('nlte' not in atm):
self.atmospheres[atm['name']].nlte = False
else:
self.atmospheres[atm['name']].nlte = hazel.util.tobool(atm['nlte'])
if (self.verbose >= 1):
self.logger.info(" * Line in NLTE if available")
else:
self.atmospheres[atm['name']].nlte = False
if ('wavelength' not in atm):
atm['wavelength'] = None
elif (atm['wavelength'] == 'None'):
atm['wavelength'] = None
if (atm['wavelength'] is not None):
wvl_range = [float(k) for k in atm['wavelength']]
else:
wvl_range = [np.min(self.spectrum[atm['spectral region']].wavelength_axis), np.max(self.spectrum[atm['spectral region']].wavelength_axis)]
if ('reference frame' in atm):
if ('line-of-sight' in atm['reference frame']):
self.atmospheres[atm['name']].reference_frame = 'line-of-sight'
if ('vertical' in atm['reference frame']):
raise Exception('Magnetic fields in photospheres are always in the line-of-sight reference frame.')
else:
self.atmospheres[atm['name']].reference_frame = 'line-of-sight'
if (self.verbose >= 1):
self.logger.info(" * Adding line : {0}".format(lines))
self.logger.info(" * Magnetic field reference frame : {0}".format(self.atmospheres[atm['name']].reference_frame))
self.atmospheres[atm['name']].add_active_line(lines=lines, spectrum=self.spectrum[atm['spectral region']],
wvl_range=np.array(wvl_range), verbose=self.verbose)
if (self.atmospheres[atm['name']].graphnet_nlte is not None):
self.set_nlte(True)
if ('ranges' in atm):
for k, v in atm['ranges'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
if (v == 'None'):
self.atmospheres[atm['name']].ranges[k2] = None
else:
self.atmospheres[atm['name']].ranges[k2] = hazel.util.tofloat(v)
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
self.atmospheres[atm['name']].regularization[k2] = None
if ('regularization' in atm):
for k, v in atm['regularization'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
if (v == 'None'):
self.atmospheres[atm['name']].regularization[k2] = None
else:
self.atmospheres[atm['name']].regularization[k2] = v
if ('reference atmospheric model' in atm):
my_file = Path(self.root + atm['reference atmospheric model'])
if (not my_file.exists()):
raise FileExistsError("Input file {0} for atmosphere {1} does not exist.".format(my_file, atm['name']))
self.atmospheres[atm['name']].load_reference_model(self.root + atm['reference atmospheric model'], self.verbose)
if (self.atmospheres[atm['name']].model_type == '3d'):
self.atmospheres[atm['name']].n_pixel = self.atmospheres[atm['name']].model_handler.get_npixel()
if ('nodes' in atm):
for k, v in atm['nodes'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
self.atmospheres[atm['name']].cycles[k2] = hazel.util.toint(v)
if ('temperature change to recompute departure coefficients' in atm):
self.atmospheres[atm['name']].t_change_departure = float(atm['temperature change to recompute departure coefficients'])
else:
self.atmospheres[atm['name']].t_change_departure = 0.0
def add_chromosphere(self, atmosphere):
"""
Programmatically add a chromosphere
Parameters
----------
atmosphere : dict
Dictionary containing the following data
'Name', 'Spectral region', 'Height', 'Line', 'Wavelength', 'Reference atmospheric model',
'Ranges', 'Nodes'
Returns
-------
None
"""
# Make sure that all keys of the input dictionary are in lower case
# This is irrelevant if a configuration file is used because this has been
# already done
atm = hazel.util.lower_dict_keys(atmosphere)
self.atmospheres[atm['name']] = Hazel_atmosphere(working_mode=self.working_mode, name=atm['name'])
if ('wavelength' not in atm):
atm['wavelength'] = None
elif (atm['wavelength'] == 'None'):
atm['wavelength'] = None
if (atm['wavelength'] is not None):
wvl_range = [float(k) for k in atm['wavelength']]
else:
wvl_range = [np.min(self.spectrum[atm['spectral region']].wavelength_axis), np.max(self.spectrum[atm['spectral region']].wavelength_axis)]
self.atmospheres[atm['name']].add_active_line(line=atm['line'], spectrum=self.spectrum[atm['spectral region']],
wvl_range=np.array(wvl_range))
if ('reference frame' in atm):
if (atm['reference frame'] == 'line-of-sight'):
self.atmospheres[atm['name']].reference_frame = 'line-of-sight'
if (atm['reference frame'] == 'vertical'):
self.atmospheres[atm['name']].reference_frame = 'vertical'
else:
self.atmospheres[atm['name']].reference_frame = 'vertical'
if (self.verbose >= 1):
self.logger.info(" * Adding line : {0}".format(atm['line']))
self.logger.info(" * Magnetic field reference frame : {0}".format(self.atmospheres[atm['name']].reference_frame))
if ('ranges' in atm):
for k, v in atm['ranges'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
if (v == 'None'):
self.atmospheres[atm['name']].ranges[k2] = None
else:
self.atmospheres[atm['name']].ranges[k2] = hazel.util.tofloat(v)
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
self.atmospheres[atm['name']].regularization[k2] = None
if ('regularization' in atm):
for k, v in atm['regularization'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
if (v == 'None'):
self.atmospheres[atm['name']].regularization[k2] = None
else:
self.atmospheres[atm['name']].regularization[k2] = v
if ('coordinates for magnetic field vector' in atm):
if (atm['coordinates for magnetic field vector'] == 'cartesian'):
self.atmospheres[atm['name']].coordinates_B = 'cartesian'
if (atm['coordinates for magnetic field vector'] == 'spherical'):
self.atmospheres[atm['name']].coordinates_B = 'spherical'
else:
self.atmospheres[atm['name']].coordinates_B = 'cartesian'
self.atmospheres[atm['name']].select_coordinate_system()
if (self.verbose >= 1):
self.logger.info(" * Magnetic field coordinates system : {0}".format(self.atmospheres[atm['name']].coordinates_B))
if ('reference atmospheric model' in atm):
my_file = Path(self.root + atm['reference atmospheric model'])
if (not my_file.exists()):
raise FileExistsError("Input file {0} for atmosphere {1} does not exist.".format(my_file, atm['name']))
self.atmospheres[atm['name']].load_reference_model(self.root + atm['reference atmospheric model'], self.verbose)
if (self.atmospheres[atm['name']].model_type == '3d'):
self.atmospheres[atm['name']].n_pixel = self.atmospheres[atm['name']].model_handler.get_npixel()
# Set values of parameters
self.atmospheres[atm['name']].height = float(atm['height'])
if ('nodes' in atm):
for k, v in atm['nodes'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
self.atmospheres[atm['name']].cycles[k2] = hazel.util.toint(v)
def add_parametric(self, atmosphere):
"""
Programmatically add a parametric atmosphere
Parameters
----------
atmosphere : dict
Dictionary containing the following data
'Name', 'Spectral region', 'Wavelength', 'Reference atmospheric model', 'Type',
'Ranges', 'Nodes'
Returns
-------
None
"""
# Make sure that all keys of the input dictionary are in lower case
# This is irrelevant if a configuration file is used because this has been
# already done
atm = hazel.util.lower_dict_keys(atmosphere)
self.atmospheres[atm['name']] = Parametric_atmosphere(working_mode=self.working_mode)
if ('wavelength' not in atm):
atm['wavelength'] = None
elif (atm['wavelength'] == 'None'):
atm['wavelength'] = None
if (atm['wavelength'] is not None):
wvl_range = [float(k) for k in atm['wavelength']]
else:
wvl_range = [np.min(self.spectrum[atm['spectral region']].wavelength_axis), np.max(self.spectrum[atm['spectral region']].wavelength_axis)]
self.atmospheres[atm['name']].add_active_line(spectrum=self.spectrum[atm['spectral region']],
wvl_range=np.array(wvl_range))
if ('ranges' in atm):
for k, v in atm['ranges'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
if (v == 'None'):
self.atmospheres[atm['name']].ranges[k2] = None
else:
self.atmospheres[atm['name']].ranges[k2] = hazel.util.tofloat(v)
if ('reference atmospheric model' in atm):
my_file = Path(self.root + atm['reference atmospheric model'])
if (not my_file.exists()):
raise FileExistsError("Input file {0} for atmosphere {1} does not exist.".format(my_file, atm['name']))
self.atmospheres[atm['name']].load_reference_model(self.root + atm['reference atmospheric model'], self.verbose)
if (self.atmospheres[atm['name']].model_type == '3d'):
self.atmospheres[atm['name']].n_pixel = self.atmospheres[atm['name']].model_handler.get_npixel()
# Set values of parameters
if ('nodes' in atm):
for k, v in atm['nodes'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
self.atmospheres[atm['name']].cycles[k2] = hazel.util.toint(v)
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
self.atmospheres[atm['name']].regularization[k2] = None
if ('regularization' in atm):
for k, v in atm['regularization'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
if (v == 'None'):
self.atmospheres[atm['name']].regularization[k2] = None
else:
self.atmospheres[atm['name']].regularization[k2] = v
def add_straylight(self, atmosphere):
"""
Programmatically add a straylight atmosphere
Parameters
----------
atmosphere : dict
Dictionary containing the following data
'Name', 'Spectral region', 'Reference atmospheric model',
'Ranges', 'Nodes'
Returns
-------
None
"""
# Make sure that all keys of the input dictionary are in lower case
# This is irrelevant if a configuration file is used because this has been
# already done
atm = hazel.util.lower_dict_keys(atmosphere)
self.atmospheres[atm['name']] = Straylight_atmosphere(working_mode=self.working_mode)
if ('wavelength' not in atm):
atm['wavelength'] = None
elif (atm['wavelength'] == 'None'):
atm['wavelength'] = None
if (atm['wavelength'] is not None):
wvl_range = [float(k) for k in atm['wavelength']]
else:
wvl_range = [np.min(self.spectrum[atm['spectral region']].wavelength_axis), np.max(self.spectrum[atm['spectral region']].wavelength_axis)]
self.atmospheres[atm['name']].add_active_line(spectrum=self.spectrum[atm['spectral region']],
wvl_range=np.array(wvl_range))
if ('ranges' in atm):
for k, v in atm['ranges'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
if (v == 'None'):
self.atmospheres[atm['name']].ranges[k2] = None
else:
self.atmospheres[atm['name']].ranges[k2] = hazel.util.tofloat(v)
my_file = Path(self.root + atm['reference atmospheric model'])
if (not my_file.exists()):
raise FileExistsError("Input file {0} for atmosphere {1} does not exist.".format(my_file, atm['name']))
if ('reference atmospheric model' in atm):
self.atmospheres[atm['name']].load_reference_model(self.root + atm['reference atmospheric model'], self.verbose)
if (self.atmospheres[atm['name']].model_type == '3d'):
self.atmospheres[atm['name']].n_pixel = self.atmospheres[atm['name']].model_handler.get_npixel()
# Set values of parameters
if ('nodes' in atm):
for k, v in atm['nodes'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
self.atmospheres[atm['name']].cycles[k2] = hazel.util.toint(v)
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
self.atmospheres[atm['name']].regularization[k2] = None
if ('regularization' in atm):
for k, v in atm['regularization'].items():
for k2, v2 in self.atmospheres[atm['name']].parameters.items():
if (k.lower() == k2.lower()):
if (v == 'None'):
self.atmospheres[atm['name']].regularization[k2] = None
else:
self.atmospheres[atm['name']].regularization[k2] = v
def remove_unused_atmosphere(self):
"""
Remove unused atmospheres
Parameters
----------
None
Returns
-------
None
"""
to_remove = []
for k, v in self.atmospheres.items():
if (not v.active):
to_remove.append(k)
if (self.verbose >= 1):
self.logger.info(' - Atmosphere {0} deleted.'.format(k))
for k in to_remove:
self.atmospheres.pop(k)
def init_sir_external(self):
"""
Initialize SIR for this synthesis
Parameters
----------
None
Returns
-------
None
"""
for k, v in self.atmospheres.items():
if (v.type == 'photosphere'):
f = open('lte.grid', 'w')
f.write("IMPORTANT: a) All items must be separated by commas. \n")
f.write(" b) The first six characters of the last line \n")
f.write(" in the header (if any) must contain the symbol --- \n")
f.write("\n")
f.write("Line and blends indices : Initial lambda Step Final lambda \n")
f.write("(in this order) (mA) (mA) (mA) \n")
f.write("-----------------------------------------------------------------------\n")
ind_low = (np.abs(v.spectrum.wavelength_axis - v.wvl_range_lambda[0])).argmin()
ind_top = (np.abs(v.spectrum.wavelength_axis - v.wvl_range_lambda[1])).argmin()
low = v.spectrum.wavelength_axis[ind_low]
top = v.spectrum.wavelength_axis[ind_top] # TODO
delta = (v.spectrum.wavelength_axis[1] - v.spectrum.wavelength_axis[0])
filename = os.path.join(os.path.dirname(__file__),'data/LINEAS')
ff = open(filename, 'r')
flines = ff.readlines()
ff.close()
for i in range(len(v.lines)):
for l in flines:
tmp = l.split()
index = int(tmp[0].split('=')[0])
if (index == v.lines[0]):
wvl = float(tmp[2])
f.write("{0} : {1}, {2}, {3}\n".format(str(v.lines)[1:-1], 1e3*(low-wvl), 1e3*delta, 1e3*(top-wvl)))
f.close()
v.n_lambda = sir_code.init_externalfile(v.index, filename)
def init_sir(self):
"""
Initialize SIR for this synthesis. This version does not make use of any external file, which might be
not safe when running in MPI mode.
Parameters
----------
None
Returns
-------
None
"""
lines = []
n_lines = 0
elements = {'H':1,'HE':2,'LI':3,'BE':4,'B':5,'C':6,'N':7,'O':8,'F':9,'NE':10,
'NA':11,'MG':12,'AL':13,'SI':14,'P':15,'S':16,'CL':17,'AR':18,'K':19,'CA':20,'SC':21,'TI':22,'V':23,'CR':24,
'MN':25,'FE':26,'CO':27,'NI':28,'CU':29,'ZN':30,'GA':31,'GE':32,'AS':33,'SE':34,'BR':35,'KR':36,
'RB':37,'SR':38,'Y':39,'ZR':40,'NB':41,'MO':42,'TC':43,'RU':44,'RH':45,'PD':46,'AG':47,'CD':48,'IN':49,
'SN':50,'SB':51,'TE':52,'I':53,'XE':54,'CS':55,'BA':56,'LA':57,'CE':58,'PR':59,'ND':60,'PM':61,
'SM':62,'EU':63,'GD':64,'TB':65,'DY':66,'HO':67,'ER':68,'TM':69,'YB':70,'LU':71,'HF':72,'TA':73,'W':74,
'RE':75,'OS':76,'IR':77,'PT':78,'AU':79,'HG':80,'TL':81,'PB':82,'BI':83,'PO':84,'AT':85,'RN':86,
'FR':87,'RA':88,'AC':89,'TH':90,'PA':91,'U':92}
states = {'S': 0, 'P': 1, 'D': 2, 'F': 3, 'G': 4, 'H': 5, 'I': 6}
for k, v in self.atmospheres.items():
if (v.type == 'photosphere'):
n_lines += 1
ind_low = (np.abs(v.spectrum.wavelength_axis - v.wvl_range_lambda[0])).argmin()
ind_top = ( | np.abs(v.spectrum.wavelength_axis - v.wvl_range_lambda[1]) | numpy.abs |
# -*- coding: utf-8 -*-
"""
==========================================
GammaEyes Version 1.0.1 ==
Created at: 2021.07.19 ==
Author@<NAME> ==
Email <EMAIL> ==
==========================================
GammaEyes is an open source software for
gamma spectrum processing and analysis.
=============== Main ====================
"""
# ======================================================================
# Import the required modules
import sys, os
# PyQt5 modules
from PyQt5.QtWidgets import *
from PyQt5 import sip, QtWidgets, QtCore, QtGui
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import (QMenu, QApplication, QTableWidgetItem)
# geGui modules
from geGui import Ui_MainWindow
# ge modules
from lib.geDenoise import geDenoise
from lib.geFindPeaks import geFindpeaks
from lib.geFwhmCali import geFwhmCali
from lib.geStable import geStabilization
from lib.geBroaden import geBroaden
from lib.geMCReader import geMCReader
from lib.geFit import geFit
from lib.geDatabase import geDatabase
from lib.geRWIO import geRWIO
from lib.geFSA import geFSA
# Else
import numpy as np
import matplotlib
matplotlib.use("Qt5Agg")
import matplotlib.pyplot as plt
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FC
from matplotlib.backends.backend_qt5 import NavigationToolbar2QT as NavigationToolbar
class MainWindow(QMainWindow,Ui_MainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
# ==========================================================================================
# Setting interface conversion
self.stackedWidget.setCurrentIndex(0)
self.pushButton.clicked.connect(lambda: self.stackedWidget.setCurrentIndex(0))
self.pushButton_2.clicked.connect(lambda: self.stackedWidget.setCurrentIndex(1))
self.pushButton_3.clicked.connect(lambda: self.stackedWidget.setCurrentIndex(2))
self.pushButton_4.clicked.connect(lambda: self.stackedWidget.setCurrentIndex(3))
self.pushButton_5.clicked.connect(lambda: self.stackedWidget.setCurrentIndex(4))
self.pushButton_6.clicked.connect(lambda: self.stackedWidget.setCurrentIndex(5))
self.pushButton_7.clicked.connect(lambda: self.stackedWidget.setCurrentIndex(6))
self.cbx_fsa_wlls_type.currentIndexChanged.connect(lambda: self.slot_cbx_fsa_wlls_change())
# ==========================================================================================
# Table Setting
# ------------------
# Table 1
# set customMenu
self.tableWidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.tableWidget.customContextMenuRequested.connect(self.showCustomMenu)
# self.setLayout(conLayout)
self.contextMenu = QMenu(self)
self.ADD = self.contextMenu.addAction('Add')
self.DELE = self.contextMenu.addAction('Delete')
self.ADD.triggered.connect(lambda: self.table_add(self.tableWidget))
self.DELE.triggered.connect(lambda: self.table_delete(self.tableWidget))
# --------
# Table 2
self.table_eva_fwhm_cr.setContextMenuPolicy(Qt.CustomContextMenu) ######
self.table_eva_fwhm_cr.customContextMenuRequested.connect(self.showCustomMenu1) ####
self.contextMenu1 = QMenu(self)
self.ADD1 = self.contextMenu1.addAction('Add')
self.DELE1 = self.contextMenu1.addAction('Delete')
self.ADD1.triggered.connect(lambda: self.table_add(self.table_eva_fwhm_cr))
self.DELE1.triggered.connect(lambda: self.table_delete(self.table_eva_fwhm_cr))
# --------
# Table 3
self.table_eva_fwhm_ln.setContextMenuPolicy(Qt.CustomContextMenu) ######
self.table_eva_fwhm_ln.customContextMenuRequested.connect(self.showCustomMenu2) ####
self.contextMenu2 = QMenu(self)
self.ADD2 = self.contextMenu2.addAction('Add')
self.DELE2 = self.contextMenu2.addAction('Delete')
self.ADD2.triggered.connect(lambda: self.table_add(self.table_eva_fwhm_ln))
self.DELE2.triggered.connect(lambda: self.table_delete(self.table_eva_fwhm_ln))
# --------
# Table 4
self.table_fit_sci.setContextMenuPolicy(Qt.CustomContextMenu) ######
self.table_fit_sci.customContextMenuRequested.connect(self.showCustomMenu3) ####
self.contextMenu3 = QMenu(self)
self.ADD3 = self.contextMenu3.addAction('Add')
self.DELE3 = self.contextMenu3.addAction('Delete')
self.ADD3.triggered.connect(lambda: self.table_add(self.table_fit_sci))
self.DELE3.triggered.connect(lambda: self.table_delete(self.table_fit_sci))
self.table_fit_semi_p.setContextMenuPolicy(Qt.CustomContextMenu) ######
self.table_fit_semi_p.customContextMenuRequested.connect(self.showCustomMenu4) ####
self.contextMenu4 = QMenu(self)
self.ADD4 = self.contextMenu4.addAction('Add')
self.DELE4 = self.contextMenu4.addAction('Delete')
self.ADD4.triggered.connect(lambda: self.table_add(self.table_fit_semi_p))
self.DELE4.triggered.connect(lambda: self.table_delete(self.table_fit_semi_p))
# --------
# Table 5
self.table_data_pgnaa.setContextMenuPolicy(Qt.CustomContextMenu) ######
self.table_data_pgnaa.customContextMenuRequested.connect(self.showCustomMenuPgaa) ####
self.contextMenuPgaa = QMenu(self)
self.Show = self.contextMenuPgaa.addAction('Show selected lines')
self.Show.triggered.connect(lambda: self.table_show(self.table_data_pgnaa))
# --------
# Table 6
self.table_data_decay.setContextMenuPolicy(Qt.CustomContextMenu) ######
self.table_data_decay.customContextMenuRequested.connect(self.showCustomMenuDecay) ####
self.contextMenuDecay = QMenu(self)
self.Show1 = self.contextMenuDecay.addAction('Show selected lines')
self.Show1.triggered.connect(lambda: self.table_show(self.table_data_decay))
# =======================================================================================
# slot connect
# ----- toolbar -----
self.pushButton_11.clicked.connect(lambda: self.slot_btn_fig_zoom())
self.pushButton_12.clicked.connect(lambda: self.slot_btn_fig_zoom_back())
self.pushButton_13.clicked.connect(lambda: self.slot_btn_fig_zoom_home())
self.pushButton_14.clicked.connect(lambda: self.slot_btn_fig_parameters())
self.pushButton_18.clicked.connect(lambda: self.slot_btn_fig_save())
self.pushButton_17.clicked.connect(lambda: self.slot_btn_data_back())
self.pushButton_16.clicked.connect(lambda: self.slot_btn_data_home())
self.pushButton_15.clicked.connect(lambda: self.slot_btn_energy_show())
# ----- start -----
self.pushButton_8.clicked.connect(lambda: self.slot_btn_open_file())
self.pushButton_9.clicked.connect(lambda: self.slot_btn_save_file())
self.pushButton_10.clicked.connect(lambda: self.slot_btn_open_energy_file())
# ----- evaluation -----
self.pbt_eva_cali_linear_do.clicked.connect(lambda: self.slot_btn_eva_cali_linear_do())
self.pbt_eva_cali_linear_save.clicked.connect(lambda: self.slot_btn_eva_cali_linear_save())
self.pbt_eva_cali_nonlinear_do.clicked.connect(lambda: self.slot_btn_eva_cali_nonlinear_do())
self.pbt_eva_cali_nonlinear_save.clicked.connect(lambda: self.slot_btn_eva_cali_nonlinear_save())
self.pbt_eva_fwhm_mc_do.clicked.connect(lambda: self.slot_btn_eva_fwhm_mcnp())
self.pbt_eva_fwhm_cr_do.clicked.connect(lambda: self.slot_btn_eva_fwhm_cear())
self.pbt_eva_fwhm_ln_do.clicked.connect(lambda: self.slot_btn_eva_fwhm_linear())
# ----- process -----
self.pbt_proc_findp_auto_do.clicked.connect(lambda: self.slot_btn_proc_findp_auto())
self.pbt_proc_findp_auto_do_2.clicked.connect(lambda: self.slot_btn_proc_findp_auto_cwt())
self.pbt_proc_denoi_fit_do.clicked.connect(lambda: self.slot_btn_proc_fit())
self.pbt_proc_denoi_wt_do.clicked.connect(lambda: self.slot_btn_proc_wavelet())
self.pbt_proc_denoi_lp_do.clicked.connect(lambda: self.slot_btn_proc_lowpass())
self.pbt_proc_denoi_emd1.clicked.connect(lambda: self.slot_btn_proc_emd_1())
self.pbt_proc_denoi_emd_do.clicked.connect(lambda: self.slot_btn_proc_emd_do())
self.pbt_proc_sta_3rp_do.clicked.connect(lambda: self.slot_btn_proc_sta_3rp_do())
self.pbt_proc_sta_2rp_do.clicked.connect(lambda: self.slot_btn_proc_sta_2rp_do())
# ----- FSA -----
self.pbt_fsa_lls_lib.clicked.connect(lambda: self.slot_btn_fsa_lls_lib())
self.pbt_fsa_lls_compo.clicked.connect(lambda: self.slot_btn_fsa_lls_compos())
self.pbt_fsa_lls_spe.clicked.connect(lambda: self.slot_btn_fsa_lls_spec())
self.pbt_fsa_lls_solve.clicked.connect(lambda: self.slot_btn_fsa_lls_solve())
self.pbt_fsa_wlls_lib.clicked.connect(lambda: self.slot_btn_fsa_wlls_lib())
self.pbt_fsa_wlls_cont.clicked.connect(lambda: self.slot_btn_fsa_wlls_compos())
self.pbt_fsa_wlls_spe.clicked.connect(lambda: self.slot_btn_fsa_wlls_spec())
self.pbt_fsa_wlls_w.clicked.connect(lambda: self.slot_btn_fsa_wlls_weight())
self.pbt_fsa_wlls_solve.clicked.connect(lambda: self.slot_btn_fsa_wlls_solve())
self.pbt_fsa_pca_lib.clicked.connect(lambda: self.slot_btn_fsa_pca_lib())
self.pbt_fsa_pca_cont.clicked.connect(lambda: self.slot_btn_fsa_pca_compos())
self.pbt_fsa_pca_spe.clicked.connect(lambda: self.slot_btn_fsa_pca_spec())
self.pbt_fsa_pca_do.clicked.connect(lambda: self.slot_btn_fsa_pca_solve())
# ----- fitting -----
self.pbt_fit_sci_do.clicked.connect(lambda: self.slot_btn_fit_sci_do())
self.pbt_fit_sci_do_2.clicked.connect(lambda: self.slot_btn_fit_semi_do())
# ----- simulation -----
self.radioButton.clicked.connect(lambda: self.slot_rbn_simu_edep())
self.radioButton_2.clicked.connect(lambda: self.slot_rbn_simu_spec())
self.rbt_simu_broaden_conv.clicked.connect(lambda: self.slot_rbn_simu_spec_conv())
self.pbt_simu_bro_mc_do.clicked.connect(lambda: self.slot_btn_simu_bro_mc_do())
self.pbt_simu_bro_mc_draw.clicked.connect(lambda: self.slot_btn_simu_bro_mc_draw())
self.pbt_simu_bro_cr_do.clicked.connect(lambda: self.slot_btn_simu_bro_cr_do())
self.pbt_simu_bro_cr_draw.clicked.connect(lambda: self.slot_btn_simu_bro_cr_draw())
self.pbt_simu_bro_ln_do.clicked.connect(lambda: self.slot_btn_simu_bro_ln_do())
self.pbt_simu_bro_ln_draw.clicked.connect(lambda: self.slot_btn_simu_bro_ln_draw())
self.pbt_simu_mcr_open.clicked.connect(lambda: self.slot_btn_simu_mcr_open())
self.pbt_simu_mcr_save.clicked.connect(lambda: self.slot_btn_simu_mcr_save())
# ----- database -----
self.pbt_data_pgaa_do.clicked.connect(lambda: self.slot_btn_data_pgnaa_do())
self.pbt_data_decay_do.clicked.connect(lambda: self.slot_btn_data_decay_do())
self.pbt_data_iso_do.clicked.connect(lambda: self.slot_btn_data_iso_do())
# =======================================================================================
# setting shadow
self.effect_shadow = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow.setOffset(0, 0) # 偏移
self.effect_shadow.setBlurRadius(10) # 阴影半径
self.effect_shadow.setColor(QtCore.Qt.gray) # 阴影颜色
self.pushButton_8.setGraphicsEffect(self.effect_shadow)
self.effect_shadow2 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow2.setOffset(0, 0) # 偏移
self.effect_shadow2.setBlurRadius(10) # 阴影半径
self.effect_shadow2.setColor(QtCore.Qt.gray) # 阴影颜色
self.pushButton_9.setGraphicsEffect(self.effect_shadow2)
self.effect_shadow3 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow3.setOffset(0, 0) # 偏移
self.effect_shadow3.setBlurRadius(10) # 阴影半径
self.effect_shadow3.setColor(QtCore.Qt.gray) # 阴影颜色
self.pushButton_10.setGraphicsEffect(self.effect_shadow3)
self.effect_shadow4 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow4.setOffset(0, 0) # 偏移
self.effect_shadow4.setBlurRadius(10) # 阴影半径
self.effect_shadow4.setColor(QtCore.Qt.gray) # 阴影颜色
self.label_4.setGraphicsEffect(self.effect_shadow4)
self.effect_shadow5 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow5.setOffset(0, 0) # 偏移
self.effect_shadow5.setBlurRadius(10) # 阴影半径
self.effect_shadow5.setColor(QtCore.Qt.gray) # 阴影颜色
self.label_17.setGraphicsEffect(self.effect_shadow5)
self.effect_shadow6 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow6.setOffset(0, 0) # 偏移
self.effect_shadow6.setBlurRadius(10) # 阴影半径
self.effect_shadow6.setColor(QtCore.Qt.gray) # 阴影颜色
self.textEdit_8.setGraphicsEffect(self.effect_shadow6)
self.effect_shadow7 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow7.setOffset(0, 0) # 偏移
self.effect_shadow7.setBlurRadius(10) # 阴影半径
self.effect_shadow7.setColor(QtCore.Qt.gray) # 阴影颜色
self.tabWidget_2.setGraphicsEffect(self.effect_shadow7)
self.effect_shadow8 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow8.setOffset(0, 0) # 偏移
self.effect_shadow8.setBlurRadius(10) # 阴影半径
self.effect_shadow8.setColor(QtCore.Qt.gray) # 阴影颜色
self.tabWidget_3.setGraphicsEffect(self.effect_shadow8)
self.effect_shadow9 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow9.setOffset(0, 0) # 偏移
self.effect_shadow9.setBlurRadius(10) # 阴影半径
self.effect_shadow9.setColor(QtCore.Qt.gray) # 阴影颜色
self.tabWidget_4.setGraphicsEffect(self.effect_shadow9)
self.effect_shadow10 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow10.setOffset(0, 0) # 偏移
self.effect_shadow10.setBlurRadius(10) # 阴影半径
self.effect_shadow10.setColor(QtCore.Qt.gray) # 阴影颜色
self.tabWidget_5.setGraphicsEffect(self.effect_shadow10)
self.effect_shadow11 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow11.setOffset(0, 0) # 偏移
self.effect_shadow11.setBlurRadius(10) # 阴影半径
self.effect_shadow11.setColor(QtCore.Qt.gray) # 阴影颜色
self.tabWidget_6.setGraphicsEffect(self.effect_shadow11)
self.effect_shadow12 = QtWidgets.QGraphicsDropShadowEffect(self)
self.effect_shadow12.setOffset(0, 0) # 偏移
self.effect_shadow12.setBlurRadius(10) # 阴影半径
self.effect_shadow12.setColor(QtCore.Qt.gray) # 阴影颜色
self.tabWidget.setGraphicsEffect(self.effect_shadow12)
# =======================================================================================
# canvas config
self.fig = plt.figure(figsize=(5, 10))
self.canvas = FC(self.fig)
# self.ax = self.fig.add_subplot(111)
self.ax = self.fig.subplots()
self.fig.subplots_adjust(top=0.93,bottom=0.08,left=0.05,right=0.98,hspace=0,wspace=0)
self.ax.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
self.gridlayout = QGridLayout(self.label_4) # 继承容器groupBox
self.gridlayout.addWidget(self.canvas, 0, 1)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
self.canvas.mpl_connect("motion_notify_event",self.slot_show_data)
# =======================================================================================
# global parameters
self.spec_now = np.zeros(0)
self.spec_last = np.zeros(0)
self.spec_ori = np.zeros(0)
self.energy = np.zeros(0)
self.energy_curve_nonlinear = np.zeros(0)
self.energy_curve_linear = np.zeros(0)
self.fwhm_curve = np.zeros(0)
self.flag_energy = False
self.flag_open_file = False
self.flas_simu_broaden = 0 # broaden algorithm type 0: sampling 1: conv
self.simu_bro_edep_fp = ""
# ===================================================================================
# 1 SLOT table operate
def showCustomMenu(self):
self.contextMenu.exec_(QCursor.pos()) # 在鼠标位置显示
def showCustomMenu1(self):
self.contextMenu1.exec_(QCursor.pos()) # 在鼠标位置显示
def showCustomMenu2(self):
self.contextMenu2.exec_(QCursor.pos()) # 在鼠标位置显示
def showCustomMenu3(self):
self.contextMenu3.exec_(QCursor.pos()) # 在鼠标位置显示
def showCustomMenu4(self):
self.contextMenu4.exec_(QCursor.pos()) # 在鼠标位置显示
def showCustomMenuPgaa(self):
self.contextMenuPgaa.exec_(QCursor.pos()) # 在鼠标位置显示
def showCustomMenuDecay(self):
self.contextMenuDecay.exec_(QCursor.pos()) # 在鼠标位置显示
def slot_cbx_fsa_wlls_change(self):
try:
if self.cbx_fsa_wlls_type.currentText()=="std":
self.pbt_fsa_wlls_w.setEnabled(False)
self.let_fsa_wlls_weight.setEnabled(False)
else:
self.pbt_fsa_wlls_w.setEnabled(True)
self.let_fsa_wlls_weight.setEnabled(True)
if len(self.let_fsa_wlls_lib.text())!=0 and len(self.let_fsa_wlls_cont.text())!=0 and len(self.let_fsa_wlls_spe.text())!=0:
if self.cbx_fsa_wlls_type.currentText() == "std":
self.pbt_fsa_wlls_solve.setEnabled(True)
elif len(self.let_fsa_wlls_weight.text()) != 0 and self.cbx_fsa_wlls_type.currentText() == "else":
self.pbt_fsa_wlls_solve.setEnabled(True)
else:
self.pbt_fsa_wlls_solve.setEnabled(False)
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
def table_add(self, table):
try:
cur_total_row = table.rowCount()
table.setRowCount(cur_total_row+1)
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
def table_delete(self, table):
try:
selected_indexs = table.selectedIndexes()
if len(selected_indexs) == 0:
return
indexs = []
for i in range(len(selected_indexs)):
index_now = selected_indexs[len(selected_indexs)-i-1].row()
if index_now not in indexs:
indexs.append(index_now)
table.removeRow(index_now)
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
def table_show(self, table):
try:
selected_indexs = table.selectedIndexes()
if len(selected_indexs) == 0:
return
indexs = []
Egamma = []
sigma = []
for i in range(len(selected_indexs)):
index_now = selected_indexs[len(selected_indexs) - i - 1].row()
if index_now not in indexs:
indexs.append(index_now)
Egamma.append(self.dataBase[index_now,5])
sigma.append(self.dataBase[index_now,7])
self.canvas_update_database(Egamma, sigma)
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
# ===================================================================================
# 2 SLOT canvas
# ----- canvas -----
def canvas_update(self):
self.ax.cla()
# self.fig.clf()
self.ax.ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
# print(len(self.spec_now))
# print(len(self.spec_last))
if self.pushButton_15.isChecked():
if len(self.spec_last) == 0: # when there is no spec_last
self.ax.plot(self.energy,self.spec_now, color="red", label="Now")
self.ax.legend()
self.canvas.draw()
else:
self.ax.plot(self.energy,self.spec_last, color="blue", label="Last")
self.ax.plot(self.energy,self.spec_now, color="red", label="Now")
self.ax.legend()
self.canvas.draw()
else:
if len(self.spec_last) == 0: # when there is no spec_last
self.ax.plot(self.spec_now, color="red", label="Now")
self.ax.legend()
self.canvas.draw()
else:
self.ax.plot(self.spec_last, color="blue", label="Last")
self.ax.plot(self.spec_now, color="red", label="Now")
self.ax.legend()
self.canvas.draw()
def canvas_update_fsa_lib(self,lib):
m,n = np.shape(lib)
self.ax.cla()
self.ax.ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
if self.pushButton_15.isChecked():
for i in range(n):
self.ax.plot(self.energy, lib[:,i])
self.ax.legend()
self.canvas.draw()
else:
for i in range(n):
self.ax.plot(lib[:, i])
self.ax.legend()
self.canvas.draw()
def canvas_update_fsa_spec(self,spec):
self.ax.cla()
self.ax.ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
if self.pushButton_15.isChecked():
self.ax.plot(self.energy, spec)
self.ax.legend()
self.canvas.draw()
else:
self.ax.plot(spec)
self.ax.legend()
self.canvas.draw()
def canvas_update_findp(self,peaks):
self.ax.cla()
# self.fig.clf()
self.ax.ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
# print(len(self.spec_now))
# print(len(self.spec_last))
if self.pushButton_15.isChecked():
self.ax.plot(self.energy, self.spec_now, color="red", label="Now")
for i in range(len(peaks)):
self.ax.axvline(x=self.energy[peaks[i]],color="green")
self.ax.legend()
self.canvas.draw()
else:
self.ax.plot(self.spec_now, color="red", label="Now")
for i in range(len(peaks)):
self.ax.axvline(x=peaks[i],color="green")
self.ax.legend()
self.canvas.draw()
def canvas_update_energy_curve(self,energy_curve):
self.ax.cla()
# self.fig.clf()
self.ax.ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
self.ax.plot(energy_curve,color="red",label="Energy Curve")
self.ax.legend()
self.canvas.draw()
def canvas_update_fit_result(self,points_x,points_y,curve_x,curve_y):
self.ax.cla()
# self.fig.clf()
self.ax.ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
self.ax.scatter(points_x,points_y,color="red",label="Points")
self.ax.plot(curve_x,curve_y,color="green",label="Curve")
self.ax.legend()
self.canvas.draw()
def canvas_update_database(self,egamma,sigma):
if len(self.spec_now)==0:
self.ax.cla()
self.ax.ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
for i in range(len(egamma)):
self.ax.plot([egamma[i],egamma[i]],[0,sigma[i]],color="red")
self.canvas.draw()
else:
if len(self.energy)==0:
QMessageBox.warning(self,
"Error!",
"Please choose the energy list")
max_in_plot = np.max(self.spec_now)
sigma = sigma/np.max(sigma)*max_in_plot
self.ax.cla()
self.ax.ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
self.ax.plot(self.energy,self.spec_now,color="blue")
for i in range(len(egamma)):
self.ax.plot([egamma[i],egamma[i]],[0,sigma[i]],color="red")
self.canvas.draw()
# ===================================================================================
# 3 SLOT information out
# ----- Do -----
def cmd_out(self,strings):
self.label_17.setText(strings)
# ----- Do -----
def info_out(self, strings):
self.textEdit_8.setText(strings)
# =======================================================
# 4 SLOT toolbar setting
def slot_btn_fig_zoom(self):
try:
self.toolbar.zoom()
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
def slot_btn_fig_zoom_back(self):
try:
self.toolbar.back()
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
def slot_btn_fig_zoom_home(self):
try:
self.toolbar.home()
except BaseException as e:
print(e.__str__())
# self.ax.plot([1, 2, 3, 4], [5, 5, 5, 5])
# self.canvas.draw()
def slot_btn_fig_parameters(self):
try:
self.toolbar.edit_parameters()
except BaseException as e:
print(e.__str__())
def slot_btn_fig_save(self):
try:
self.toolbar.save_figure()
except BaseException as e:
print(e.__str__())
def slot_btn_data_back(self):
try:
if len(self.spec_last) != 0:
self.spec_now = self.spec_last + 0
self.spec_last = np.zeros(0)
self.canvas_update()
self.cmd_out("DO: 已清除上一步操作")
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
def slot_btn_data_home(self):
try:
self.spec_now = self.spec_ori + 0
self.spec_last = np.zeros(0)
self.canvas_update()
self.cmd_out("DO: 已返回原始能谱")
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
def slot_btn_energy_show(self):
try:
if len(self.energy) == 0:
QMessageBox.warning(self,
"Error!",
"Please choose the Energy file")
self.pushButton_15.setChecked(False)
else:
self.canvas_update()
self.cmd_out("DO: Show the Energy")
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
def slot_show_data(self, event):
try:
info = " " + str(int(event.xdata * 10000) / 10000) + " " + str(int(event.ydata * 10000) / 10000)
self.lbl_canvas_data.setText(info)
except BaseException as e:
pass
# ===================================================================================
# 5 SLOT Start
# ----- open the spectrum file -----
def slot_btn_open_file(self):
try:
self.spec_now = np.zeros(0)
self.spec_last = np.zeros(0)
fileName_choose, filetype = QFileDialog.getOpenFileName(self,
"Open the spectrum",
"./", # original path
"txt (*.txt);;chn (*.Chn);;spe (*.Spe);;mca (*.mca);;tka (*.TKA);;All Files (*)"
) # filetype filter
if fileName_choose == "":
return
gr = geRWIO(fileName_choose,filetype.split(" ")[0])
self.spec_now = gr.spec
self.spec_ori = self.spec_now+0
self.flag_open_file = True
if filetype.split(" ")[0]!="txt" and filetype.split(" ")[0]!="tka":
self.energy = gr.energy_list
self.canvas_update()
self.cmd_out("DO: Open the spectrum: "+fileName_choose)
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
# ----- open the spectrum file -----
def slot_btn_save_file(self):
try:
if len(self.spec_now)==0:
QMessageBox.warning(self,
"Error!",
"There is no spectrum")
return
file_path,file_type = QFileDialog.getSaveFileName(self, "Save the spectrum",
"./spectrum",
"Text Files (*.txt);;all files(*.*)")
if file_path == "":
# print("\n取消选择")
return
np.savetxt(file_path, self.spec_now)
self.cmd_out("DO: Save spectrum at " + file_path)
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
# ----- open the energy file -----
def slot_btn_open_energy_file(self):
try:
fileName_choose, filetype = QFileDialog.getOpenFileName(self,
"Choose energy file",
"./", # 起始路径
"All Files (*);;Text Files (*.txt)") # 设置文件扩展名过滤,用双分号间隔
if fileName_choose == "":
# print("\n取消选择")
return
# label show
self.energy = np.loadtxt(fileName_choose)
self.flag_energy = True
# self.canvas_update()
self.cmd_out("DO: Open the energy file "+fileName_choose)
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
# ===================================================================================
# 6 SLOT Evaluation
# 1.calibration
def slot_btn_eva_cali_linear_do(self):
try:
if len(self.spec_now)==0:
QMessageBox.warning(self,
"Error!",
"Please choose spectrum")
return
peak1 = [int(self.let_eva_cali_linear_p1.text()),float(self.let_eva_cali_linear_e1.text())]
peak2 = [int(self.let_eva_cali_linear_p2.text()), float(self.let_eva_cali_linear_e2.text())]
k = (peak2[1]-peak1[1])/(peak2[0]-peak1[0])
b = peak1[1]-k*peak1[0]
self.energy_curve_linear = np.zeros(len(self.spec_now))
for i in range(len(self.spec_now)):
self.energy_curve_linear[i] = k*i+b
info = "Finish the FWHM calibration\n"
info = info + "=============\n"
info = info + "The curve is: E = k*Chan+b\n"
info = info + "=============\n"
info = info+"k: "+str(k)+"\n" + "b: "+str(b)+"\n" + "=============\n"
self.info_out(info)
self.canvas_update_energy_curve(self.energy_curve_linear)
self.cmd_out("DO: Finish the linear energy curve's calibration")
pass
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
def slot_btn_eva_cali_linear_save(self):
try:
if len(self.energy_curve_linear)==0:
QMessageBox.warning(self,
"Error!",
"Please calibration first")
return
file_path,filetype = QFileDialog.getSaveFileName(self, "Save the energy curve","C:/Users/Administrator/Desktop/energy_linear",
"Text Files (*.txt);;all files(*.*)")
print(file_path)
if file_path=="":
# print("\n取消选择")
return
np.savetxt(file_path,self.energy_curve_linear)
self.cmd_out("DO: Save the linear energy curve at "+file_path)
pass
except BaseException as e:
QMessageBox.warning(self,
"Error!",
e.__str__())
def slot_btn_eva_cali_nonlinear_do(self):
try:
if len(self.spec_now)==0:
QMessageBox.warning(self,
"Error!",
"Please choose spectrum")
return
p1, e1 = int(self.let_eva_cali_nonlinear_p1.text()), float(self.let_eva_cali_nonlinear_e1.text())
p2, e2 = int(self.let_eva_cali_nonlinear_p2.text()), float(self.let_eva_cali_nonlinear_e2.text())
p3, e3 = int(self.let_eva_cali_nonlinear_p4.text()), float(self.let_eva_cali_nonlinear_e3.text())
arr1 = | np.array([p1**2,p2**2,p3**2]) | numpy.array |
#This is the basis for an N-Body Code created by
#<NAME> and <NAME>
import numpy as np
import matplotlib.pyplot as plt
GravitationalConstant = 6.67408e-11
class body: # universal body container
def __init__ (self, mass, position, velocity): # body creation
self.m = mass
self.x = position
self.v = velocity
self.a = np.array([0,0,0])
def distance (self, otherbody): # distance to another body calculator
r = self.x - otherbody.x
r = np.sqrt(np.dot(r, r))
return r
def gravitate (self, otherbody): # two body gravitation acceleration calculator
r= self.x - otherbody.x
r = r*((np.dot(r,r))**(-1.5))
self.a += -GravitationalConstant*otherbody.m*r
otherbody.a += GravitationalConstant*self.m*r
def resetacc(self): # acceleration reset procedure
self.a = [0,0,0]
def velocity2(self): # V^2
return np.dot(self.v,self.v)
def magnitude(vector):
return np.sqrt(np.dot(vector,vector))
def orbitalcalc(ecc, perihelium, msun): # orbit parameters
return np.sqrt(GravitationalConstant*msun*(1+ecc)/(perihelium))
def initialiser(total_time, steps_per_year, mode, integration_scheme, par1 ='+'):
global N,SS,dt,endtime,eccen #total num of bodies and the solar system
if mode=='kozai':
N=3
vel=orbitalcalc(0.5, 1.496e10, 1.989e30)
SS=np.array([body(1.989e30,np.array([0.,0.,0.]),np.array([0.,0.,0.])),
body(1.989e29,np.array([1.496e11,0.,0.]),np.array([0.,2.979e4,0.])),
body(5.972e24,np.array([-1.496e10,0,0]),np.array([0,-vel*0.5,vel*(np.sqrt(3)/2)]))])
elif mode=='cluster1':
N=30
#Define parsec in metres
parsec=3.0857e16
solarmass=1.989e30
radius=0.25*parsec
SS=[]
for i in range(N):
#Random position in spherical coordinates
pos=np.random.random_sample((3,))*np.array([radius,np.pi,2*np.pi])
posx=pos[0]*np.sin(pos[1])* | np.cos(pos[2]) | numpy.cos |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Program for
Created on %(date)
@author : trismonock
@mail : <EMAIL>
"""
# import standard modules
import os
os.environ["OPENBLAS_NUM_THREADS"] = "3" # openblas thread number (problem for Python 3)
import numpy as np
import glob
from numpy.linalg import inv
# get and define the working directory
base_dir = os.getcwd() + "/"
os.chdir(base_dir)
# define dirs
input_dir = os.path.realpath(base_dir + "../../SIM_RET/OUTPUT") + "/"
output_dir = os.path.realpath(base_dir + "../OUTPUT") + "/"
# create dir
try:
os.makedirs(output_dir)
except OSError:
pass
# define cases
stat_list = glob.glob(input_dir + "statistics*.dat")
stat_list = np.sort(stat_list)
nfiles = len(stat_list)
print(stat_list)
print(nfiles)
# loop over pixels
for i in range(nfiles):
# print statement
print("Info | Executing error analysis pixel id : ", i+1)
# define init string
kmat_list = glob.glob(input_dir + "kmat_" + str(i+1).zfill(5) + "_*.dat")
# define number of iteration
nkmat = len(kmat_list)
# define filename
kmat_file = input_dir + "kmat_" + str(i+1).zfill(5) + "_" + str(nkmat).zfill(2) + ".dat"
# open and read data
data = | np.loadtxt(kmat_file) | numpy.loadtxt |
"""
Colorizing the text mask.
Change the original code to Python3 support and simplifed the code structure.
Original project: https://github.com/ankush-me/SynthText
Author: <NAME>
Date: 2015
"""
import cv2
import numpy as np
import copy
import matplotlib.pyplot as plt
import scipy.interpolate as si
import scipy.ndimage as scim
import scipy.ndimage.interpolation as sii
import os
import os.path as osp
import pickle as cp
from PIL import Image
import random
from . import poisson_reconstruct
class Layer(object):
def __init__(self, alpha, color):
# alpha for the whole image:
assert alpha.ndim == 2
self.alpha = alpha
[n,m] = alpha.shape[:2]
color = np.atleast_1d( | np.array(color) | numpy.array |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# SPDX-FileCopyrightText: 2022 Madureira, Brielen
# SPDX-License-Identifier: MIT
"""
An object to load datasets and create the datapoints for each set.
It loads probes from JSON files and representations from h5 files
and then constructs datasets for the probing classifier task.
"""
import json
import pickle
from collections import Counter, defaultdict
import h5py
import numpy as np
from torch.utils.data import Dataset
from aux import (get_reps_path, get_probes_path, get_test_lens_path,
get_embs_path)
from tasks import get_task_labels
# fixed number of turns in all train/valid dialogues
VISDIAL_LEN = 11
class ProbingDataset(Dataset):
"""Build a dataset split."""
def __init__(self, params, split):
"""
Args:
params (dataclass): All parameters of the experiment.
split (str): Train, valid or test.
"""
self.params = params
self.split = split
self.labels, self.label_names = self._define_labels()
self.representations = self._load_representations()
self.label_counter = Counter()
self.datapoints = {}
self._create_datapoints()
def __len__(self):
"""Return number of datapoints."""
return len(self.datapoints)
def __getitem__(self, index):
"""Retrieve a datapoint given its index."""
dialogue_id, _, sent_id, turn, label = self.datapoints[index]
sent_embedding = self.id2sent[sent_id]
representation = self.representations[dialogue_id, turn]
return (index, representation, sent_embedding, label)
def _define_labels(self):
"""Get labels and their names according to main task."""
return get_task_labels(self.params.bot, self.params.task)
def _load_lens(self):
"""Return dict of dialogue lens, which is constant if not test set."""
if self.split != 'test':
return defaultdict(lambda: VISDIAL_LEN)
path = get_test_lens_path()
with open(path, 'r') as f:
lens = {}
for line in f.readlines():
idx, length = line.strip('\n').split('\t')
lens[idx] = int(length)
return lens
def _load_representations(self):
"""Load dialogue representations."""
path = get_reps_path(self.params, self.split)
name = f'{self.split}_dialogue_representations'
representations = np.array(h5py.File(path, 'r').get(name))
# Define control task
if self.params.control_task == 'rand-reps' and self.split == 'train':
# replace representations by random vectors
np.random.seed(self.params.random_seed)
r_mean = | np.mean(representations) | numpy.mean |
import unittest
import numpy as np
from . import plot
import funcsfa
class TestInvalidInputs(unittest.TestCase):
def setUp(self):
self.rand = np.random.RandomState(1968486074)
self.n_factors = 9
self.f = funcsfa.SFA()
self.n_samples = 221
self.n_features = 37
self.X_a = self.rand.normal(0, 1, (self.n_samples, 30))
self.X_b = self.rand.normal(0, 1, (self.n_samples, 7))
self.data_one = funcsfa.DataMatrix(self.X_a)
self.data_two = funcsfa.StackedDataMatrix([
funcsfa.DataMatrix(self.X_a),
funcsfa.DataMatrix(self.X_b)])
def test_l1_penalty_length_one_dt(self):
self.f.fit(self.data_one, self.n_factors, max_iter=0, l1=0.0)
self.f.fit(self.data_one, self.n_factors, max_iter=0, l1=0.0, l2=0.0)
self.f.fit(self.data_one, self.n_factors, max_iter=0, l1=[0.0], l2=0.0)
self.f.fit(self.data_one, self.n_factors, max_iter=0, l1=[0.0],
l2=[0.0])
with self.assertRaises(Exception):
self.f.fit(self.data_one, self.n_factors, max_iter=0,
l1=[0.0, 0.1])
with self.assertRaises(Exception):
self.f.fit(self.data_one, self.n_factors, max_iter=0,
l1=[])
with self.assertRaises(Exception):
self.f.fit(self.data_one, self.n_factors, max_iter=0,
l1=[0.1, 0.2], l2=[0.1])
with self.assertRaises(Exception):
self.f.fit(self.data_one, self.n_factors, max_iter=0,
l1=[0.1, 0.2], l2=0.1)
def test_l2_penalty_length_one_dt(self):
self.f.fit(self.data_one, self.n_factors, max_iter=0, l1=0.0, l2=[0.0])
with self.assertRaises(Exception):
self.f.fit(self.data_one, self.n_factors, max_iter=0,
l2=[0.0, 0.1])
with self.assertRaises(Exception):
self.f.fit(self.data_one, self.n_factors, max_iter=0,
l2=[])
with self.assertRaises(Exception):
self.f.fit(self.data_one, self.n_factors, max_iter=0,
l2=[0.1, 0.2], l1=[0.1])
with self.assertRaises(Exception):
self.f.fit(self.data_one, self.n_factors, max_iter=0,
l2=[0.1, 0.2], l1=0.1)
def test_more_factors_than_features(self):
with self.assertRaises(Exception):
self.f.fit(self.data_two, self.data_two.dt_n_features[0]+1,
max_iter=0)
with self.assertRaises(Exception):
self.f.fit(self.data_two, self.data_two.dt_n_features[1]+1,
max_iter=0)
def test_invalid_transform(self):
f = funcsfa.SFA()
with self.assertRaises(Exception):
f.transform(self.data_one)
f.fit(self.data_one, self.n_factors, max_iter=10)
f.transform(self.data_one)
f.transform(self.data_one)
with self.assertRaises(Exception):
f.transform(self.data_two)
with self.assertRaises(Exception):
f.transform(self.data_two.data)
class TestSingleDatatypeReproduceRandom(unittest.TestCase):
def setUp(self):
self.n_samples = 400
self.n_features = 2000
self.n_factors = 10
self.rand = np.random.RandomState(1968486074)
self.B = self.rand.normal(0, 1, (self.n_features, self.n_factors))
Zvar = np.linspace(10, 1, self.n_factors)
Zvar = Zvar / np.mean(Zvar)
self.Z = self.rand.normal(0, np.sqrt(Zvar),
(self.n_samples, self.n_factors))
self.X = np.dot(self.Z, self.B.T)
self.data = funcsfa.DataMatrix(self.X)
self.f = funcsfa.SFA()
def test_init_full_factors_output_shapes(self):
Z_estimated = self.f.fit_transform(self.data, self.n_factors,
max_iter=0)
self.assertEqual(Z_estimated.shape, (self.n_samples, self.n_factors))
self.assertEqual(self.f.coefficients[0].shape,
(self.n_features, self.n_factors))
assert not np.any(np.isnan(Z_estimated))
assert not np.any(np.isnan(self.f.coefficients[0]))
def test_init_full_factors_reconstruction(self):
Z_estimated = self.f.fit_transform(self.data, self.n_factors,
max_iter=0)
self.assertAlmostEqual(self.f.reconstruction_error, 0.0)
X_reconstructed = (np.dot(Z_estimated, self.f.coefficients[0].T) +
np.mean(self.X, 0, keepdims=True))
np.testing.assert_allclose(self.X, X_reconstructed)
def test_init_full_factors_constraints(self):
Z_estimated = self.f.fit_transform(self.data, self.n_factors,
max_iter=0)
np.testing.assert_allclose(1, np.mean(Z_estimated ** 2))
def test_init_part_factors_output_shapes(self):
n_factors = self.n_factors // 2
Z_estimated = self.f.fit_transform(self.data, n_factors, max_iter=0)
self.assertEqual(Z_estimated.shape, (self.n_samples, n_factors))
self.assertEqual(self.f.coefficients[0].shape,
(self.n_features, n_factors))
assert not np.any(np.isnan(Z_estimated))
assert not np.any(np.isnan(self.f.coefficients[0]))
def test_init_part_factors_constraints(self):
n_factors = self.n_factors // 2
Z_estimated = self.f.fit_transform(self.data, n_factors, max_iter=0)
np.testing.assert_allclose(1, np.mean(Z_estimated ** 2))
Z_estimated2 = self.f.transform(self.data)
np.testing.assert_allclose(1, | np.mean(Z_estimated2 ** 2) | numpy.mean |
import numpy as np
def IoU(window1: np.ndarray, window2: np.ndarray) -> np.ndarray:
"""
:param window1: shape=(N, 2)
:param window2: shape=(N, 2)
:return IoUs: shape=(N,)
"""
intersection_size = np.maximum(
0,
| np.minimum(window1[:,1], window2[:,1]) | numpy.minimum |
#!/usr/bin/env python
import matplotlib.pyplot as plt
import librosa.display
import numpy as np
import subprocess
import librosa
import pysrt
import sys
import os
import re
DIRNAME = os.path.dirname(os.path.realpath(__file__))
TRAIN_DIR = os.path.join(DIRNAME, 'training')
FREQ = 16000 # Audio frequency
N_MFCC = 13
HOP_LEN = 512.0 # Num of items per sample
# 1 item = 1/16000 seg = 32 ms
ITEM_TIME = HOP_LEN/FREQ
if not os.path.exists(TRAIN_DIR):
print("missing training data in directory:", TRAIN_DIR)
sys.exit(1)
# Convert timestamp to seconds
def timeToSec(t):
total_sec = float(t.milliseconds)/1000
total_sec += t.seconds
total_sec += t.minutes*60
total_sec += t.hours*60*60
return total_sec
# Return timestamp from cell position
def timeToPos(t, freq=FREQ, hop_len=HOP_LEN):
return round(timeToSec(t)/(hop_len/freq))
"""
Uses ffmpeg to transcode and extract audio from movie files in the training
directory. Function returns a list of tuples; the .wav files and corresponding
.srt files to processing
"""
def transcode_audio(dir=TRAIN_DIR):
files = os.listdir(dir)
p = re.compile('.*\.[mkv|avi|mp4]')
files = [ f for f in files if p.match(f) ]
training = []
for f in files:
name, extension = os.path.splitext(f)
input = os.path.join(dir, f)
output = os.path.join(dir, name + '.wav')
srt = os.path.join(dir, name + '.srt')
if not os.path.exists(srt):
print("missing subtitle for training:", srt)
sys.exit(1)
training.append((output, srt))
if os.path.exists(output):
continue
print("Transcoding:", input)
command = "ffmpeg -y -i {0} -ab 160k -ac 2 -ar {2} -vn {1}".format(input, output, FREQ)
code = subprocess.call(command, stderr=subprocess.DEVNULL, shell=True)
if code != 0:
raise Exception("ffmpeg returned: {}".format(code))
return training
"""
Extracts the features and labels from the .wav and .srt file. The audio is
processed using MFCC. Returns a tuple where the first element is the MFCC data
and the second argument is the labels for the data.
"""
def extract_features(files=None):
if files is None:
files = transcode_audio()
audio = []
labels = []
for (wav, srt) in files:
print("Processing audio:", wav)
y, sr = librosa.load(wav, sr=FREQ)
mfcc = librosa.feature.mfcc(y=y, sr=sr, hop_length=int(HOP_LEN), n_mfcc=int(N_MFCC))
label = extract_labels(srt, len(mfcc[0]))
audio.append(mfcc)
labels.append(label)
return audio, labels
"""
Processes a .srt file and returns a numpy array of labels for each sample. If
there is a subtitle at the i'th sample, there is a 1 at position i, else 0.
"""
def extract_labels(srt, samples):
subs = pysrt.open(srt)
labels = | np.zeros(samples) | numpy.zeros |
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from ...pvtpy.black_oil import Pvt,Oil,Water,Gas
from scipy.optimize import root_scalar
from .inflow import OilInflow, GasInflow
from ...utils import intercept_curves
from typing import Union
## Incompressible pressure drop
def potential_energy_change(
z1:Union[int,float]=None,
z2=None,
delta_z=None,
length=None,
ge=1,
angle=None,
inc=None,
p1=0):
"""potential_energy_change [ Δp PE accounts for the pressure change due to the weight of the column of fluid (the hydrostatic head); it
will be zero for flow in a horizontal pipe.
In this equation, Δz is the difference in elevation between positions 1 and 2, with z increasing upward. θ
is defined as the angle between horizontal and the direction of flow. Thus, θ is +90° for upward, vertical
flow, 0° for horizontal flow, and –90° for downward flow in a vertical well (Figure 7-4). For flow in a
straight pipe of length L with flow direction θ,]
Parameters
----------
z1 : [type], optional
[description], by default None
z2 : [type], optional
[description], by default None
delta_z : [type], optional
[description], by default None
length : [type], optional
[description], by default None
ge : int, optional
[description], by default 1
angle : [type], optional
[description], by default None
inc : [type], optional
[description], by default None
p1 : int, optional
[description], by default 0
Returns
-------
[type]
[description]
"""
# Assert height difference types
if delta_z is None:
if length is None:
assert isinstance(z1,(float,int,np.ndarray,np.int64,np.float64)) and isinstance(z2,(float,int,np.ndarray,np.int64,np.float64)), f"{type(z1)} {type(z2)}"
z1 = np.atleast_1d(z1)
z2 = np.atleast_1d(z2)
#assert z1.shape == (1,) and z2.shape == (1,)
delta_z = z1-z2
else:
assert isinstance(length,(float,int,np.ndarray,np.int64,np.float64))
length = np.atleast_1d(length)
#assert length.shape == (1,)
if angle is None:
assert isinstance(inc,(float,int,np.ndarray,np.int64,np.float64))
inc = np.atleast_1d(inc)
assert inc <= 90 and inc >= -90
sign = np.sign(inc)
angle = (90 - np.abs(inc)) * sign
else:
# Assert angle between -90 and 90
assert isinstance(angle,(float,int,np.ndarray,np.int64,np.float64))
angle = np.atleast_1d(angle)
assert angle <= 90 and angle >= -90
delta_z = length * np.sin(np.radians(angle))
else:
assert isinstance(delta_z,(float,int,np.ndarray,np.int64,np.float64))
delta_z = np.atleast_1d(delta_z)
#assert delta_z.shape == (1,)
#Assert ge be positive
assert isinstance(ge,(float,int,np.ndarray,np.int64,np.float64)) and ge>0, f"{ge} {type(ge)} not allowed"
#Calculate Delta P
delta_p = 0.433 * ge * delta_z
#Calculate P2
p2 = p1 + delta_p
return delta_p, p2
def kinetic_energy_change(d1=None,d2=None, ge=1,rate=None,p1=0):
"""
Δp KE is the pressure drop resulting from a change in the velocity of the fluid between positions 1 and 2.
It will be zero for an incompressible fluid unless the cross-sectional area of the pipe is different at the
two positions of interest.
Petroleum Production Systems, Economides. Chapter 7 7.2.3.2. Δp KE, the Pressure Drop Due to Kinetic Energy Change. Page 172
"""
assert isinstance(d1,(float,int,np.ndarray,np.int64,np.float64)) and isinstance(d2,(float,int,np.ndarray,np.int64,np.float64))
d1 = np.atleast_1d(d1)
d2 = np.atleast_1d(d2)
#Assert Specifi Gravity be positive
assert isinstance(ge,(float,int,np.ndarray,np.int64,np.float64)) and ge>0
ge = np.atleast_1d(ge)
# Rate in bbl/d
assert isinstance(rate,(float,int,np.ndarray,np.int64,np.float64)) and rate>=0
rate = np.atleast_1d(rate)
#Estimate Density in lb/ft3
rho = 62.4 * ge
#Estimate delta Pressure in psi
delta_p = 1.53e-8 * np.power(rate,2) * rho * ((1/np.power(d1,4))-(1/np.power(d2,4)))
p2 = p1 + delta_p
return delta_p, p2
def reynolds_number(rate,rho,d,mu):
"""
Reynolds Number where q is in bbl/d, ρ in lb m /ft 3 , D in in., and μ in cp.
"""
nre = (1.48 * rate * rho) / (d * mu)
return nre
def frictional_pressure_drop(
rate=None,
epsilon=0.001,
ge=1,
d=None,
mu=1,
length=None):
# Rate in bbl/d
assert isinstance(rate,(float,int,np.ndarray,np.int64,np.float64)) and rate>=0
rate = np.atleast_1d(rate)
# pipe relative roughness
assert isinstance(epsilon,(float,int,np.ndarray,np.int64,np.float64))
epsilon = np.atleast_1d(epsilon)
#Assert Specifi Gravity be positive
assert isinstance(ge,(float,int,np.ndarray,np.int64,np.float64)) and ge>0
ge = np.atleast_1d(ge)
assert isinstance(d,(float,int,np.ndarray,np.int64,np.float64))
d = np.atleast_1d(d)
assert isinstance(mu,(float,int,np.ndarray,np.int64,np.float64))
mu = np.atleast_1d(mu)
assert isinstance(length,(float,int,np.ndarray,np.int64,np.float64))
length = np.atleast_1d(length)
#Estimate Density in lb/ft3
rho = 62.4 * ge
#Reynolds Number
nre = reynolds_number(rate,rho,d,mu)
#Friction Factor
if nre == 0:
ff = 0
else:
ff = np.power((1/(-4*np.log10((epsilon/3.7065)-(5.0452/nre)*np.log10((np.power(epsilon,1.1098)/2.8257)+np.power(7.149/nre,0.8981))))),2)
#Velocity ft/s
u = (4*rate*5.615)/(np.pi*np.power(d/12,2)*86400)
delta_p = (2 * ff * rho * np.power(u,2) * length)/(32.17 * (d/12) * 144)
delta_p *= -1
return delta_p
def one_phase_pressure_profile(
p1=0,
ge=1,
epsilon=0.001,
md=None,
tvd=None,
d = None,
rate = None,
mu=None,
backwards=1
):
assert isinstance(md,(int,float,list,np.ndarray))
md = np.atleast_1d(md)
if tvd is None:
tvd = md
else:
assert isinstance(tvd,(int,float,list,np.ndarray))
tvd = np.atleast_1d(tvd)
assert isinstance(d,(int,float,list,np.ndarray))
if isinstance(d,(int,float)):
d = np.full(md.shape,d)
else:
d = np.atleast_1d(d)
assert isinstance(rate,(int,float, np.ndarray))
rate = np.atleast_1d(rate)
assert isinstance(mu,(int,float, np.ndarray))
mu = np.atleast_1d(mu)
assert isinstance(p1,(int,float, np.ndarray))
p1 = np.atleast_1d(p1)
assert isinstance(ge,(int,float, np.ndarray))
ge = np.atleast_1d(ge)
assert isinstance(epsilon,(int,float, np.ndarray))
epsilon = np.atleast_1d(epsilon)
assert md.shape[0] == tvd.shape[0] == d.shape[0]
n = md.shape[0]
#Create arrays
pressure = np.zeros(n)
ppe = np.zeros(n)
pke = np.zeros(n)
pf = np.zeros(n)
delta_p = np.zeros(n)
gradient = np.zeros(n)
pressure[0] = p1
for i in range(1,n):
#Potential Energy Change
ppe[i], _ = potential_energy_change(
z1=tvd[i-1],
z2=tvd[i],
ge= ge,
)
#Kinetic Energy Change
pke[i], _ = kinetic_energy_change(
d1=d[i-1],
d2=d[i],
rate=rate,
ge=ge,
)
#Frictional Pressure drop
pf[i] = frictional_pressure_drop(
rate=rate,
epsilon=epsilon,
ge=ge,
d=d[i],
mu=mu,
length=np.abs(md[i-1]-md[i])
) * backwards
delta_p[i] = ppe[i] + pke[i] + pf[i]
pressure[i] = pressure[i-1] + delta_p[i]
gradient[i] = (pressure[i] - pressure[i-1])/np.abs(tvd[i] - tvd[i-1])
# Create dataframe
pressure_profile = pd.DataFrame({
'md':md,
'tvd':tvd,
'diameter':d,
'pressure':pressure,
'ppe': ppe,
'pke': pke,
'pf' : pf,
'delta_p': delta_p,
'gradient': gradient
}).set_index('md')
p2 = pressure[-1]
return pressure_profile, p2
## Gas Outflow functions
def gas_pressure_profile_correlation(thp,sg,depth):
assert isinstance(thp,(float,int,np.ndarray,np.int64,np.float64))
thp = np.atleast_1d(thp)
assert thp.ndim == 1
assert isinstance(sg,(float,int,np.ndarray,np.int64,np.float64))
sg = np.atleast_1d(sg)
assert sg.shape == (1,)
assert isinstance(depth,(list,float,int,np.ndarray))
depth = np.atleast_1d(depth)
assert sg.ndim == 1
pwf = thp*np.exp(3.47e-5*depth)
return pwf
def gas_pressure_profile(
md = None,
inc = None,
thp = None,
rate = None,
gas_obj = None,
di=2.99,
surf_temp=80,
temp_grad=1,
epsilon = 0.0006,
tol = 0.05,
max_iter=20):
"""
To calculate the pressure drop in a gas well, the compressibility of the fluid must be considered. When
the fluid is compressible, the fluid density and fluid velocity vary along the pipe, and these variations
must be included when integrating the mechanical energy balance equation.
Petroleum Production Systems, Economides. Chapter 7 7.3. Single-Phase Flow of a Compressible, Newtonian Fluid. Page 175
"""
# Assert the right types and shapes for input
assert isinstance(md, (np.ndarray,pd.Series))
md = np.atleast_1d(md)
assert md.ndim ==1
assert isinstance(inc, (int,float,np.ndarray,pd.Series))
if isinstance(inc,np.ndarray):
assert inc.shape == md.shape
else:
inc = np.full(md.shape,inc)
angle = np.radians(90 - inc)
assert isinstance(thp, (int,np.int64,np.float64,float,np.ndarray)), f'{type(thp)} not accepted'
thp = np.atleast_1d(thp)
assert thp.shape == (1,)
assert isinstance(gas_obj,Gas) and gas_obj.pvt is not None
assert isinstance(di, (int,float,np.ndarray))
if isinstance(di,np.ndarray):
assert di.shape == md.shape
else:
di = np.full(md.shape,di)
assert isinstance(rate, (int,float,np.ndarray))
rate = np.atleast_1d(rate)
assert rate.shape == (1,)
assert gas_obj.sg is not None
#Create the variables
pressure_profile = np.zeros(md.shape)
temperature_profile = np.zeros(md.shape)
pressure_gradient = np.zeros(md.shape)
pressure_profile[0] = thp
temperature_profile[0] = surf_temp
interations = np.zeros(md.shape)
if gas_obj.chromatography is not None:
df_rho = gas_obj.chromatography.get_rhog(p=thp,t=surf_temp, rhog_method='real_gas')
else:
df_rho = gas_obj.pvt.interpolate(thp,property='rhog')
grad_guess = df_rho['rhog'].values*(0.433/62.4)
#Loop over depth
for i in range(1,md.shape[0]):
err = tol + 0.01
dz = np.sin(angle[i])*(md[i]-md[i-1])
gas_sg = gas_obj.sg
it = 0
while err>= tol and it <= max_iter:
p_guess = grad_guess*(md[i]-md[i-1])*np.sin(angle[i]) + pressure_profile[i-1]
#Interpolate pvt
df_pvt = gas_obj.pvt.interpolate(p_guess)
#Reynolds Number
#nre = (4*28.97*gas_obj.sg*rate*14.7)/(np.pi*di[i]*df_pvt['mug'].values*10.73*520)
nre = 20.09*(gas_sg*rate)/(di[i]*df_pvt['mug'].values)
#Friction Factor
friction = np.power((1/(-4*np.log10((epsilon/3.7065)-(5.0452/nre)*np.log10((np.power(epsilon,1.1098)/2.8257)+np.power(7.149/nre,0.8981))))),2)
#Temperature
temperature_profile[i] = dz * (temp_grad/100) + temperature_profile[i-1]
#S
s = (-0.0375*gas_obj.sg*dz)/(df_pvt['z'].values*(temperature_profile[i]+460))
#Calculate next pressure by parts for easily read
a = np.exp(-s) * np.power(pressure_profile[i-1],2)
b = (friction*np.power(df_pvt['z'].values*(temperature_profile[i]+460)*rate,2))/(np.sin(angle[i])*np.power(di[i],5))
c = 1 - np.exp(-s)
p_new = np.sqrt(a - (2.685e-3*b*c))
grad_new = (p_new - pressure_profile[i-1])/dz
err = np.abs(grad_guess-grad_new)/grad_new
grad_guess = grad_new
it +=1
pressure_gradient[i] = grad_new
pressure_profile[i] = p_new
interations[i] = it
df_dict = {
'pressure':pressure_profile,
'pressure_gradient': pressure_gradient,
'temperature': temperature_profile,
'iterations': interations
}
df = pd.DataFrame(df_dict, index = md)
pwf = pressure_profile[-1]
return df, pwf
def gas_upward_pressure(
md = None,
inc = None,
pwf = None,
rate = None,
gas_obj = None,
di=2.99,
surf_temp=80,
temp_grad=1,
epsilon = 0.0006,
tol = 0.05,
max_iter=20,
guess=None,
grad_guess = [0.02,0.05]
):
if guess is None:
grad = np.atleast_1d(grad_guess)
delta_h = np.abs(md[-1] - md[0])
guess = pwf - grad * delta_h
else:
assert isinstance(guess,(list,np.ndarray))
guess = np.atleast_1d(guess)
def solve(x):
_,_pwf = gas_pressure_profile(
md = md,
inc = inc,
thp = x,
rate = rate,
gas_obj = gas_obj,
di=di,
surf_temp=surf_temp,
temp_grad=temp_grad,
epsilon = epsilon,
tol = tol,
max_iter=max_iter,
)
return pwf - _pwf
sol = root_scalar(solve, x0=guess[0],x1=guess[1])
return sol.root
def gas_outflow_curve(
md = None,
inc = None,
thp = None,
gas_obj = None,
rate=None,
min_rate=100,
max_rate=8000,
n_rate=20,
di=2.99,
surf_temp=80,
temp_grad=1,
epsilon = 0.0006,
tol = 0.05,
max_iter=20,
operating_point = None,
op_n = 30
):
# Assert the right types and shapes for input
assert isinstance(md, (np.ndarray,pd.Series)) and md.ndim ==1
md = np.atleast_1d(md)
assert isinstance(inc, (int,float,np.ndarray,pd.Series))
if isinstance(inc,np.ndarray):
assert inc.shape == md.shape
else:
inc = np.full(md.shape,inc)
angle = np.radians(90 - inc)
assert isinstance(thp, (int,float,list,np.ndarray))
thp = np.atleast_1d(thp)
assert thp.ndim == 1
assert isinstance(gas_obj,Gas) and gas_obj.pvt is not None
assert isinstance(di, list)
assert isinstance(rate, (int,float,list,np.ndarray,type(None)))
if rate is None:
rate = np.linspace(min_rate,max_rate,n_rate)
else:
rate = np.atleast_1d(rate)
assert rate.ndim == 1
assert gas_obj.sg is not None
pwf = np.zeros(rate.shape[0]*thp.shape[0]*len(di))
thp_arr = np.zeros(pwf.shape)
di_arr = np.zeros(pwf.shape)
gas_arr = np.zeros(pwf.shape)
name_list = []
i = 0
for p in thp:
for d in di:
for q in rate:
_,pwf[i] = gas_pressure_profile(
md = md,
inc = inc,
thp = p,
rate = q,
gas_obj = gas_obj,
surf_temp=surf_temp,
temp_grad=temp_grad,
di=d
)
gas_arr[i] = q
thp_arr[i] = p
di_arr[i] = d
case_name = f'thp-{p}_di-{d}'
name_list.append(case_name)
i += 1
#df = pd.DataFrame(pwf,columns=name_list,index=rate)
arr=np.column_stack((pwf,thp_arr,di_arr))
df = pd.DataFrame(arr,columns=['pwf','thp','di'],index=gas_arr)
df['case'] = name_list
df.index.name = 'gas'
op = pd.DataFrame()
if operating_point is not None:
inflow = operating_point.df
for case in df['case'].unique():
df_case = df[df['case']==case]
points, idx = intercept_curves(inflow['q'],inflow['p'],df_case.index,df_case['pwf'], n=op_n)
points_df = pd.DataFrame(points[[-1],:], columns=['q','p'])
points_df['case'] = case
points_df['idx'] = idx
op = op.append(points_df)
op = op.merge(df.groupby('case').mean(), left_on='case', right_on='case')
return df, op
### Multiphase Pressure Gradients
def flow_regime_plot(
ql=None,
qg=None,
d=2.99,
sg_liquid = 1,
surface_tension=30,
ax=None,
method = 'duns_ros',
**kwargs
):
"""
Plot Flow Regime from Duns and Ros Flow Regime Map
Coordinates extracted from Figure7-10 Duns and Ros Flow Regime Map
https://apps.automeris.io/wpd/
Petroleum Production Systems, Economides. Chapter 7 7.2.3.2. Δp KE, the Pressure Drop Due to Kinetic Energy Change. Page 84
"""
if d is not None:
assert isinstance(d,(int,float,list,np.ndarray,pd.Series))
d = np.atleast_1d(d)
# Estimate Cross section Area [ft2] from diameter [in]
a = np.power((d*0.5)/12,2)*np.pi
if ql is not None:
assert isinstance(ql,(int,float,list,np.ndarray,pd.Series))
ql = np.atleast_1d(ql)
#Liquid velocity. Convert bbl/d to ft3/s then divide area. Result velocity in ft/s
usl = (ql * 5.616 * (1/86400))/a
#Calculate the dimensionless numbers for each phase
nvl = 1.938 * usl * np.power((sg_liquid*62.4)/surface_tension,0.25)
if qg is not None:
assert isinstance(ql,(int,float,list,np.ndarray,pd.Series))
qg = np.atleast_1d(qg)
#Gas velocity. Convert ft3/d to ft3/s then divide area. Result velocity in ft/s
usg = (qg * (1/86400))/a
nvg = 1.938 * usg * np.power((sg_liquid*62.4)/surface_tension,0.25)
if method == 'duns_ros':
fax= ax or plt.gca()
region_1_2 = np.array([
[1.1753722651306362, 0.1082636733874053],
[1.1913061720030635, 0.16102620275609392],
[1.3268047497147244, 0.23950266199874834],
[1.4777148689707504, 0.35154183187529914],
[1.7604108438655526, 0.5228664844415476],
[2.1544346900318843, 0.7880462815669913],
[2.8585141796844757, 1.2358165955824107],
[3.545745842465605, 1.790084628235539],
[5.529553425383406, 3.2470894518548166],
[8.507942799627454, 5.512889788770675],
[16.68100537200059, 11.566937549363251],
[29.76351441631322, 20.43359717856943],
[61.58482110660267, 39.079952122756026],
[41.11829402435837, 27.703123342457815],
[79.53985507023424, 48.93900918477497],
])
region_2_t = np.array([
[53.10631887314356, 0.10543589908346815],
[59.146605445917515, 0.18139306939110614],
[66.7669293918757, 0.36097012876068046],
[80.61813527211957, 0.7674630429274295],
[104.12232560483065, 1.5475873545578884],
[141.92103954525945, 2.7338936055226313],
[270.8622850933671, 5.9684569951223105],
[204.14630347954724, 4.230939172613499],
[340.53655850163904, 7.674630429274299],
[503.2159359259993, 12.195704601594414],
[714.1692874235849, 18.380944176677932],
[922.3851039358485, 23.324701361610806],
])
region_t_3 = np.array([
[92.23851039358486, 0.10684043121253317],
[97.34285811778867, 0.15475873545578891],
[105.53385749880759, 0.24269312356542563],
[115.96514767613999, 0.41204298882016666],
[136.30221830031346, 0.7278953843983147],
[183.29807108324394, 1.2358165955824107],
[263.6650898730361, 2.271547585601246],
[364.25331154496416, 4.120429888201667],
[531.0631887314356, 6.995642156712631],
[714.1692874235849, 11.264816923358868],
[947.5632026539927, 18.139306939110632],
])
fax.plot(region_1_2[:,0],region_1_2[:,1], color='black',linestyle='--')
fax.plot(region_2_t[:,0],region_2_t[:,1], color='black',linestyle='--')
fax.plot(region_t_3[:,0],region_t_3[:,1], color='black',linestyle='--')
fax.set_ylabel('Nvl')
fax.set_ylabel('Nvg')
fax.set_title('Duns and Ros Flow Regime Map')
fax.set_xlim([0.1,1000])
fax.set_ylim([0.1,100])
annot = kwargs.pop('ann',True)
font = kwargs.pop('fontsize',8)
if annot:
fax.annotate(
f"Region I \n Bubble Flow or \n low-velocity slug flow",
xy = (0.2,0.15),
xycoords='data',
xytext=(0, 0),
textcoords='offset points',
bbox={'boxstyle':'round', 'fc':'0.8'},
fontsize = font
)
fax.annotate(
f"Region II \n High-velocity Flow or \n churn flow",
xy = (2,0.15),
xycoords='data',
xytext=(0, 0),
textcoords='offset points',
bbox={'boxstyle':'round', 'fc':'0.8'},
fontsize = font
)
fax.annotate(
f"Region III \n Annular Flow Pattern",
xy = (300,0.15),
xycoords='data',
xytext=(0, 0),
textcoords='offset points',
bbox={'boxstyle':'round', 'fc':'0.8'},
fontsize = font
)
if ql is not None and qg is not None:
fax.scatter(nvg,nvl,color='blue',marker = "^")
if method == 'taitel_dukler':
fax= ax or plt.gca()
region_E = np.array([
[14.977474763452001, 0.0022033318988979545],
[14.977474763452001, 0.006595844345274293],
[14.977474763452001, 0.04746934676639568],
[14.777148689707504, 0.9165263295637442],
[14.977474763452001, 6.87270243904312],
[14.977474763452001, 15.857064005032758]
])
region_A = np.array([
[0.08858667904100832, 0.0022372323125884317],
[0.08858667904100832, 0.005091596044287256],
[0.0986624843178949, 0.018460289732281962],
[0.11137395078578621, 0.04142593768347061],
[0.1326804749714725, 0.08679099331751502],
[0.1668100537200059, 0.18431459769950134],
[0.21256187881919958, 0.3275265038954424],
[0.30575961084169306, 0.695276382058884],
[0.46415888336127775, 1.2691784682206282],
[0.7336637748600019, 2.019816384578137],
[0.9223851039358476, 2.412109197346714]
])
region_B = np.array([
[0.028585141796844758, 3.4805610999729812],
[0.0531063188731435, 3.5220947122633963],
[0.08623280529014943, 3.517016970779084],
[0.24649769667586238, 3.2292570594299215],
[0.8978760230238888, 2.4455928433916867],
[2.0971883035581533, 1.7556200043179786],
[5.239601353002639, 4.20919831000811],
[10.412232560483055, 7.572933314656229],
[14.579502008614657, 10.657087726496014],
])
region_D = np.array([
[0.26366508987303583, 0.44861391200434203],
[0.30575961084169306, 0.4018483957905594],
[0.4398198780581129, 0.2288467215238852],
[0.5032159359259996, 0.16920697751727592],
[0.5835551032264551, 0.11058672774921392],
[0.6676692939187563, 0.05647578739286295],
[0.6951927961775606, 0.03743162248826758],
[0.7536903980898542, 0.02284801683862376],
[0.7639077845044221, 0.015565548854263186],
[0.7436096708208817, 0.011357807043115235],
[0.7847599703514607, 0.006933286608265855],
[0.7536903980898542, 0.0027304200384003397],
[0.7436096708208817, 0.002162999360197944],
])
fax.plot(region_A[:,0],region_A[:,1], color='black',linestyle='--')
fax.plot(region_B[:,0],region_B[:,1], color='black',linestyle='--')
fax.plot(region_D[:,0],region_D[:,1], color='black',linestyle='--')
fax.plot(region_E[:,0],region_E[:,1], color='black',linestyle='--')
fax.set_ylabel('Usg [m/s]')
fax.set_ylabel('Usl [m/s]')
fax.set_title('Taitel-Dukler flow regime map')
fax.set_xlim([0.01,100])
fax.set_ylim([0.001,10])
if ql is not None and qg is not None:
fax.scatter(usg*0.3048,usl*0.3048,color='blue',marker = "^")
fax.set_yscale('log')
fax.set_xscale('log')
def hb_correlation(
pressure=None, #Pressure [psi]
temperature=None, #Temperature [F]
liquid_rate=None, # Liquid Flow [bbl/d]
gas_rate=None, # gas flow [kscfd]
ten_liquid=None, #Surface tension dyne/cm2
rho_liquid=None, # density lb/ft3
rho_gas=None, # density lb/ft3
mu_liquid=None, # Viscosity [cp]
mu_gas=None, # Viscosity [cp]
z=1, # Gas compressibility Factor
di=None, # Diameter,
epsilon = 0.0006,
):
"""
The modified Hagedorn and Brown method (mH-B) is an empirical two-phase flow correlation based
on the original work of Hagedorn and Brown (1965). The heart of the Hagedorn-Brown method is a
correlation for liquid holdup; the modifications of the original method include using the no-slip holdup
when the original empirical correlation predicts a liquid holdup value less than the no-slip holdup and
the use of the Griffith correlation (Griffith and Wallis, 1961) for the bubble flow regime.
Petroleum Production Systems, Economides. Chapter 7 7.4.3.1. The Modified Hagedorn and Brown Method Page 187
"""
#Check types and converto to np.ndarray
assert isinstance(pressure,(int,float,np.ndarray,np.float64,np.int64))
pressure = np.atleast_1d(pressure)
assert isinstance(temperature,(int,float,np.ndarray,np.float64,np.int64))
temperature = np.atleast_1d(temperature)
assert isinstance(liquid_rate,(int,float,np.ndarray,np.float64,np.int64))
liquid_rate = np.atleast_1d(liquid_rate)
assert isinstance(gas_rate,(int,float,np.ndarray,np.float64,np.int64))
gas_rate = np.atleast_1d(gas_rate)
assert isinstance(ten_liquid,(int,float,np.ndarray,np.float64,np.int64))
ten_liquid = np.atleast_1d(ten_liquid)
assert isinstance(rho_liquid,(int,float,np.ndarray,np.float64,np.int64))
rho_liquid = np.atleast_1d(rho_liquid)
assert isinstance(rho_gas,(int,float,np.ndarray,np.float64,np.int64))
rho_gas = np.atleast_1d(rho_gas)
assert isinstance(mu_liquid,(int,float,np.ndarray,np.float64,np.int64))
mu_liquid = np.atleast_1d(mu_liquid)
assert isinstance(mu_gas,(int,float,np.ndarray,np.float64,np.int64))
mu_gas = np.atleast_1d(mu_gas)
assert isinstance(z,(int,float,np.ndarray,np.float64,np.int64))
z = np.atleast_1d(z)
assert isinstance(di,(int,float,np.ndarray,np.float64,np.int64))
di = np.atleast_1d(di)
assert isinstance(epsilon,(int,float,np.ndarray,np.float64,np.int64))
epsilon = np.atleast_1d(epsilon)
griffith = False
area = np.power((di*0.5)/12,2)*np.pi
usl = (liquid_rate * 5.615)/(area * 86400)
usg = (4*gas_rate*1000*z*(460+temperature)*14.7)/(86400*pressure*520*np.pi*np.power(di/12,2))
#Mixure Velocity
um = usl + usg
lambda_g = usg / um
lambda_l = 1 - lambda_g
#Check if Buble flow exist
lb = 1.071 - 0.2218 * (np.power(um,2)/(di/12))
if lb < 0.13:
lb = 0.13
if lb > lambda_g:
yl=1-0.5*(1+(um/0.8)-np.sqrt(np.power(1+(um/0.8),2)-4*(usg/0.8)))
griffith=True
else:
#Calculate Dimensionless numbers
nvl= 1.938*usl*np.power(rho_liquid/ten_liquid,0.25) #Liquid Velocity Number
nvg=1.938*usg*np.power(rho_liquid/ten_liquid,0.25) #Gas Velocity Number
nd=120.872*(di/12)*np.power(rho_liquid/ten_liquid,0.5) #Pipe Diameter Number
nl=0.15726*mu_liquid*np.power(1/(rho_liquid * np.power(ten_liquid,3)),0.25)
#cnl=(0.0019+0.0322*nl-0.6642*np.power(nl,2)+4.9951*np.power(nl,3))/(1+10.0147*nl-33.8696*np.power(nl,2)+277.2817*np.power(nl,3)) # original
cnl=(0.0019+0.0505*nl-0.0929*np.power(nl,2)+0.061*np.power(nl,3)) #pengtools
# H
h = (nvl/np.power(nvg,0.575)) * np.power(pressure/14.7,0.1) * (cnl/nd)
#yi/phi ratio
yl_ratio = np.power(((0.0047+1123.32*h-729489.64*np.power(h,2))/(1+1097.1566*h-722153.97*np.power(h,2))),0.5)
#B
b = nvg * np.power(nl,0.38)/np.power(nd,2.14)
#Psi calculated by equation from pengtools
# https://wiki.pengtools.com/index.php?title=Hagedorn_and_Brown_correlation
if b > 0.055:
psi = 2.5714*b + 1.5962
elif b > 0.025:
psi = -533.33*np.power(b,2) + 58.524*b + 0.1171
else:
psi = 27170*np.power(b,3) - 317.52 * np.power(b,2) + 0.5472*b + 0.9999
# Psi calculated from Economides
#psi=(1.0886+69.9473*b-2334.3497*np.power(b,2)+12896.683*np.power(b,3))/(1+53.4401*b-1517.9369*np.power(b,2)+8419.8115*np.power(b,3))
#yl
yl = yl_ratio * psi
if yl < lambda_l:
yl = lambda_l
# Mass flow in lb/d
mass_flow = area * (usl * rho_liquid + usg * rho_gas) * 86400
#Reynolds Number
nre = (2.2e-2 * mass_flow) / ((di/2) * np.power(mu_liquid,yl) * np.power(mu_gas,1-yl))
#Friction Factor
ff = np.power((1/(-4*np.log10((epsilon/3.7065)-(5.0452/nre)*np.log10((np.power(epsilon,1.1098)/2.8257)+np.power(7.149/nre,0.8981))))),2)
#Average density
rho_avg = yl*rho_liquid + (1-yl)*rho_gas
if griffith:
pressure_gradient = (1/144)*(rho_avg+((ff*np.power(mass_flow,2))/(7.413e10*np.power(di/12,5)*rho_avg*np.power(yl,2))))
else:
pressure_gradient = (1/144)*(rho_avg+((ff*np.power(mass_flow,2))/(7.413e10*np.power(di/12,5)*rho_avg)))
return pressure_gradient
def gray_correlation(
pressure=None, #Pressure [psi]
temperature=None, #Temperature [F]
liquid_rate=None, # Liquid Flow [bbl/d]
gas_rate=None, # gas flow [kscfd]
ten_liquid=None, #Surface tension dyne/cm2
rho_liquid=None, # density lb/ft3
rho_gas=None, # density lb/ft3
mu_liquid=None, # Viscosity [cp]
mu_gas=None, # Viscosity [cp]
z=1, # Gas compressibility Factor
di=None, # Diameter,
epsilon = 0.0006,
):
#Check types and converto to np.ndarray
assert isinstance(pressure,(int,float,np.ndarray,np.float64,np.int64))
pressure = np.atleast_1d(pressure)
assert isinstance(temperature,(int,float,np.ndarray,np.float64,np.int64))
temperature = np.atleast_1d(temperature)
assert isinstance(liquid_rate,(int,float,np.ndarray,np.float64,np.int64))
liquid_rate = np.atleast_1d(liquid_rate)
assert isinstance(gas_rate,(int,float,np.ndarray,np.float64,np.int64))
gas_rate = np.atleast_1d(gas_rate)
assert isinstance(ten_liquid,(int,float,np.ndarray,np.float64,np.int64))
ten_liquid = np.atleast_1d(ten_liquid)
assert isinstance(rho_liquid,(int,float,np.ndarray,np.float64,np.int64))
rho_liquid = np.atleast_1d(rho_liquid)
assert isinstance(rho_gas,(int,float,np.ndarray,np.float64,np.int64))
rho_gas = np.atleast_1d(rho_gas)
assert isinstance(mu_liquid,(int,float,np.ndarray,np.float64,np.int64))
mu_liquid = np.atleast_1d(mu_liquid)
assert isinstance(mu_gas,(int,float,np.ndarray,np.float64,np.int64))
mu_gas = np.atleast_1d(mu_gas)
assert isinstance(z,(int,float,np.ndarray,np.float64,np.int64))
z = | np.atleast_1d(z) | numpy.atleast_1d |
# Licensed under a 3-clause BSD style license - see LICENSE.rst
# coding=utf-8
"""
Classes and utilities for operating the wavefront sensors of the MMTO and analyzing the data they produce
"""
import warnings
import pathlib
import numpy as np
import photutils
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from skimage import feature
from scipy import ndimage, optimize
from scipy.ndimage import rotate
from scipy.spatial import cKDTree
import lmfit
import astropy.units as u
from astropy.io import fits
from astropy.io import ascii
from astropy import stats, visualization, timeseries
from astropy.modeling.models import Gaussian2D, Polynomial2D
from astropy.modeling.fitting import LevMarLSQFitter
from astropy.table import conf as table_conf
from astroscrappy import detect_cosmics
from ccdproc.utils.slices import slice_from_string
from .config import recursive_subclasses, merge_config, mmtwfs_config
from .telescope import TelescopeFactory
from .f9topbox import CompMirror
from .zernike import ZernikeVector, zernike_slopes, cart2pol, pol2cart
from .custom_exceptions import WFSConfigException, WFSAnalysisFailed, WFSCommandException
import logging
import logging.handlers
log = logging.getLogger("WFS")
log.setLevel(logging.INFO)
warnings.simplefilter(action="ignore", category=FutureWarning)
table_conf.replace_warnings = ['attributes']
__all__ = ['SH_Reference', 'WFS', 'F9', 'NewF9', 'F5', 'Binospec', 'MMIRS', 'WFSFactory', 'wfs_norm', 'check_wfsdata',
'wfsfind', 'grid_spacing', 'center_pupil', 'get_apertures', 'match_apertures', 'aperture_distance', 'fit_apertures',
'get_slopes', 'make_init_pars', 'slope_diff', 'mk_wfs_mask']
def wfs_norm(data, interval=visualization.ZScaleInterval(contrast=0.05), stretch=visualization.LinearStretch()):
"""
Define default image normalization to use for WFS images
"""
norm = visualization.mpl_normalize.ImageNormalize(
data,
interval=interval,
stretch=stretch
)
return norm
def check_wfsdata(data, header=False):
"""
Utility to validate WFS data
Parameters
----------
data : FITS filename or 2D ndarray
WFS image
Returns
-------
data : 2D np.ndarray
Validated 2D WFS image
"""
hdr = None
if isinstance(data, (str, pathlib.PosixPath)):
# we're a fits file (hopefully)
try:
with fits.open(data, ignore_missing_simple=True) as h:
data = h[-1].data # binospec images put the image data into separate extension so always grab last available.
if header:
hdr = h[-1].header
except Exception as e:
msg = "Error reading FITS file, %s (%s)" % (data, repr(e))
raise WFSConfigException(value=msg)
if not isinstance(data, np.ndarray):
msg = "WFS image data in improper format, %s" % type(data)
raise WFSConfigException(value=msg)
if len(data.shape) != 2:
msg = "WFS image data has improper shape, %dD. Must be 2D image." % len(data.shape)
raise WFSConfigException(value=msg)
if header and hdr is not None:
return data, hdr
else:
return data
def mk_wfs_mask(data, thresh_factor=50., outfile="wfs_mask.fits"):
"""
Take a WFS image and mask/scale it so that it can be used as a reference for pupil centering
Parameters
----------
data : FITS filename or 2D ndarray
WFS image
thresh_factor : float (default: 50.)
Fraction of maximum value below which will be masked to 0.
outfile : string (default: wfs_mask.fits)
Output FITS file to write the resulting image to.
Returns
-------
scaled : 2D ndarray
Scaled and masked WFS image
"""
data = check_wfsdata(data)
mx = data.max()
thresh = mx / thresh_factor
data[data < thresh] = 0.
scaled = data / mx
if outfile is not None:
fits.writeto(outfile, scaled)
return scaled
def wfsfind(data, fwhm=7.0, threshold=5.0, plot=True, ap_radius=5.0, std=None):
"""
Use photutils.DAOStarFinder() to find and centroid spots in a Shack-Hartmann WFS image.
Parameters
----------
data : FITS filename or 2D ndarray
WFS image
fwhm : float (default: 5.)
FWHM in pixels of DAOfind convolution kernel
threshold : float
DAOfind threshold in units of the standard deviation of the image
plot: bool
Toggle plotting of the reference image and overlayed apertures
ap_radius : float
Radius of plotted apertures
"""
# data should be background subtracted first...
data = check_wfsdata(data)
if std is None:
mean, median, std = stats.sigma_clipped_stats(data, sigma=3.0, maxiters=5)
daofind = photutils.DAOStarFinder(fwhm=fwhm, threshold=threshold*std, sharphi=0.95)
sources = daofind(data)
if sources is None:
msg = "WFS spot detection failed or no spots detected."
raise WFSAnalysisFailed(value=msg)
# this may be redundant given the above check...
nsrcs = len(sources)
if nsrcs == 0:
msg = "No WFS spots detected."
raise WFSAnalysisFailed(value=msg)
# only keep spots more than 1/4 as bright as the max. need this for f/9 especially.
sources = sources[sources['flux'] > sources['flux'].max()/4.]
fig = None
if plot:
fig, ax = plt.subplots()
fig.set_label("WFSfind")
positions = list(zip(sources['xcentroid'], sources['ycentroid']))
apertures = photutils.CircularAperture(positions, r=ap_radius)
norm = wfs_norm(data)
ax.imshow(data, cmap='Greys', origin='lower', norm=norm, interpolation='None')
apertures.plot(color='red', lw=1.5, alpha=0.5, axes=ax)
return sources, fig
def grid_spacing(data, apertures):
"""
Measure the WFS grid spacing which changes with telescope focus.
Parameters
----------
data : WFS image (FITS or np.ndarray)
apertures : `~astropy.table.Table`
WFS aperture data to analyze
Returns
-------
xspacing, yspacing : float, float
Average grid spacing in X and Y axes
"""
data = check_wfsdata(data)
x = np.arange(data.shape[1])
y = np.arange(data.shape[0])
bx = np.arange(data.shape[1]+1)
by = np.arange(data.shape[0]+1)
# bin the spot positions along the axes and use Lomb-Scargle to measure the grid spacing in each direction
xsum = np.histogram(apertures['xcentroid'], bins=bx)
ysum = np.histogram(apertures['ycentroid'], bins=by)
k = np.linspace(10.0, 50., 1000) # look for spacings from 10 to 50 pixels (plenty of range, but not too small to alias)
f = 1.0 / k # convert spacing to frequency
xp = timeseries.LombScargle(x, xsum[0]).power(f)
yp = timeseries.LombScargle(y, ysum[0]).power(f)
# the peak of the power spectrum will coincide with the average spacing
xspacing = k[xp.argmax()]
yspacing = k[yp.argmax()]
return xspacing, yspacing
def center_pupil(input_data, pup_mask, threshold=0.8, sigma=10., plot=True):
"""
Find the center of the pupil in a WFS image using skimage.feature.match_template(). This generates
a correlation image and we centroid the peak of the correlation to determine the center.
Parameters
----------
data : str or 2D ndarray
WFS image to analyze, either FITS file or ndarray image data
pup_mask : str or 2D ndarray
Pupil model to use in the template matching
threshold : float (default: 0.0)
Sets image to 0 where it's below threshold * image.max()
sigma : float (default: 20.)
Sigma of gaussian smoothing kernel
plot : bool
Toggle plotting of the correlation image
Returns
-------
cen : tuple (float, float)
X and Y pixel coordinates of the pupil center
"""
data = np.copy(check_wfsdata(input_data))
pup_mask = check_wfsdata(pup_mask).astype(np.float64) # need to force float64 here to make scipy >= 1.4 happy...
# smooth the image to increae the S/N.
smo = ndimage.gaussian_filter(data, sigma)
# use skimage.feature.match_template() to do a fast cross-correlation between the WFS image and the pupil model.
# the location of the peak of the correlation will be the center of the WFS pattern.
match = feature.match_template(smo, pup_mask, pad_input=True)
find_thresh = threshold * match.max()
t = photutils.detection.find_peaks(match, find_thresh, box_size=5, centroid_func=photutils.centroids.centroid_com)
if t is None:
msg = "No valid pupil or spot pattern detected."
raise WFSAnalysisFailed(value=msg)
peak = t['peak_value'].max()
xps = []
yps = []
# if there are peaks that are very nearly correlated, average their positions
for p in t:
if p['peak_value'] >= 0.95*peak:
xps.append(p['x_centroid'])
yps.append(p['y_centroid'])
xp = np.mean(xps)
yp = np.mean(yps)
fig = None
if plot:
fig, ax = plt.subplots()
fig.set_label("Pupil Correlation Image (masked)")
ax.imshow(match, interpolation=None, cmap=cm.magma, origin='lower')
ax.scatter(xp, yp, marker="+", color="green")
return xp, yp, fig
def get_apertures(data, apsize, fwhm=5.0, thresh=7.0, plot=True, cen=None):
"""
Use wfsfind to locate and centroid spots. Measure their S/N ratios and the sigma of a 2D gaussian fit to
the co-added spot.
Parameters
----------
data : str or 2D ndarray
WFS image to analyze, either FITS file or ndarray image data
apsize : float
Diameter/width of the SH apertures
Returns
-------
srcs : astropy.table.Table
Detected WFS spot positions and properties
masks : list of photutils.ApertureMask objects
Masks used for aperture centroiding
snrs : 1D np.ndarray
S/N for each located spot
sigma : float
"""
data = check_wfsdata(data)
# set maxiters to None to let this clip all the way to convergence
if cen is None:
mean, median, stddev = stats.sigma_clipped_stats(data, sigma=3.0, maxiters=None)
else:
xcen, ycen = int(cen[0]), int(cen[1])
mean, median, stddev = stats.sigma_clipped_stats(data[ycen-50:ycen+50, xcen-50:ycen+50], sigma=3.0, maxiters=None)
# use wfsfind() and pass it the clipped stddev from here
with warnings.catch_warnings():
warnings.simplefilter("ignore")
srcs, wfsfind_fig = wfsfind(data, fwhm=fwhm, threshold=thresh, std=stddev, plot=plot)
# we use circular apertures here because they generate square masks of the appropriate size.
# rectangular apertures produced masks that were sqrt(2) too large.
# see https://github.com/astropy/photutils/issues/499 for details.
apers = photutils.CircularAperture(
list(zip(srcs['xcentroid'], srcs['ycentroid'])),
r=apsize/2.
)
masks = apers.to_mask(method='subpixel')
sigma = 0.0
snrs = []
if len(masks) >= 1:
spot = np.zeros(masks[0].shape)
for m in masks:
subim = m.cutout(data)
# make co-added spot image for use in calculating the seeing
if subim.shape == spot.shape:
spot += subim
signal = subim.sum()
noise = np.sqrt(stddev**2 * subim.shape[0] * subim.shape[1])
snr = signal / noise
snrs.append(snr)
snrs = np.array(snrs)
# set up 2D gaussian model plus constant background to fit to the coadded spot
with warnings.catch_warnings():
# ignore astropy warnings about issues with the fit...
warnings.simplefilter("ignore")
g2d = Gaussian2D(amplitude=spot.max(), x_mean=spot.shape[1]/2, y_mean=spot.shape[0]/2)
p2d = Polynomial2D(degree=0)
model = g2d + p2d
fitter = LevMarLSQFitter()
y, x = np.mgrid[:spot.shape[0], :spot.shape[1]]
fit = fitter(model, x, y, spot)
sigma = 0.5 * (fit.x_stddev_0.value + fit.y_stddev_0.value)
return srcs, masks, snrs, sigma, wfsfind_fig
def match_apertures(refx, refy, spotx, spoty, max_dist=25.):
"""
Given reference aperture and spot X/Y positions, loop through reference apertures and find closest spot. Use
max_dist to exclude matches that are too far from reference position. Return masks to use to denote validly
matched apertures.
"""
refs = np.array([refx, refy])
spots = np.array([spotx, spoty])
match = np.nan * np.ones(len(refx))
matched = []
for i in np.arange(len(refx)):
dists = np.sqrt((spots[0]-refs[0][i])**2 + (spots[1]-refs[1][i])**2)
min_i = np.argmin(dists)
if np.min(dists) < max_dist:
if min_i not in matched:
match[i] = min_i
matched.append(min_i)
else:
if min_i not in matched:
match[i] = np.nan
ref_mask = ~np.isnan(match)
src_mask = match[ref_mask]
return ref_mask, src_mask.astype(int)
def aperture_distance(refx, refy, spotx, spoty):
"""
Calculate the sum of the distances between each reference aperture and the closest measured spot position.
This total distance is the statistic to minimize when fitting the reference aperture grid to the data.
"""
refs = np.array([refx, refy]).transpose()
spots = np.array([spotx, spoty]).transpose()
tree = cKDTree(refs)
mindist, _ = tree.query(spots)
tot_dist = mindist.sum()
return np.log(tot_dist)
def fit_apertures(pars, ref, spots):
"""
Scale the reference positions by the fit parameters and calculate the total distance between the matches.
The parameters of the fit are:
``xc, yc = center positions``
``scale = magnification of the grid (focus)``
``xcoma, ycoma = linear change in magnification as a function of x/y (coma)``
'ref' and 'spots' are assumed to be dict-like and must have the keys 'xcentroid' and 'ycentroid'.
Parameters
----------
pars : list-like
The fit parameters passed in as a 5 element list: (xc, yc, scale, xcoma, ycoma)
ref : dict-like
Dict containing ``xcentroid`` and ``ycentroid`` keys that contain the reference X and Y
positions of the apertures.
spots : dict-like
Dict containing ``xcentroid`` and ``ycentroid`` keys that contain the measured X and Y
positions of the apertures.
Returns
-------
dist : float
The cumulative distance between the matched reference and measured aperture positions.
"""
xc = pars[0]
yc = pars[1]
scale = pars[2]
xcoma = pars[3]
ycoma = pars[4]
refx = ref['xcentroid'] * (scale + ref['xcentroid'] * xcoma) + xc
refy = ref['ycentroid'] * (scale + ref['ycentroid'] * ycoma) + yc
spotx = spots['xcentroid']
spoty = spots['ycentroid']
dist = aperture_distance(refx, refy, spotx, spoty)
return dist
def get_slopes(data, ref, pup_mask, fwhm=7., thresh=5., cen=[255, 255],
cen_thresh=0.8, cen_sigma=10., cen_tol=50., spot_snr_thresh=3.0, plot=True):
"""
Analyze a WFS image and produce pixel offsets between reference and observed spot positions.
Parameters
----------
data : str or 2D np.ndarray
FITS file or np.ndarray containing WFS observation
ref : `~astropy.table.Table`
Table of reference apertures
pup_mask : str or 2D np.ndarray
FITS file or np.ndarray containing mask used to register WFS spot pattern via cross-correlation
fwhm : float (default: 7.0)
FWHM of convolution kernel applied to image by the spot finding algorithm
thresh : float (default: 5.0)
Number of sigma above background for a spot to be considered detected
cen : list-like with 2 elements (default: [255, 255])
Expected position of the center of the WFS spot pattern in form [X_cen, Y_cen]
cen_thresh : float (default: 0.8)
Masking threshold as fraction of peak value used in `~photutils.detection.find_peaks`
cen_sigma : float (default: 10.0)
Width of gaussian filter applied to image by `~mmtwfs.wfs.center_pupil`
cen_tol : float (default: 50.0)
Tolerance for difference between expected and measureed pupil center
spot_snr_thresh : float (default: 3.0)
S/N tolerance for a WFS spot to be considered valid for analysis
plot : bool
Toggle plotting of image with aperture overlays
Returns
-------
results : dict
Results of the wavefront slopes measurement packaged into a dict with the following keys:
slopes - mask np.ndarry containing the slope values in pixel units
pup_coords - pupil coordinates for the position for each slope value
spots - `~astropy.table.Table` as returned by photutils star finder routines
src_aps - `~photutils.aperture.CircularAperture` for each detected spot
spacing - list-like of form (xspacing, yspacing) containing the mean spacing between rows and columns of spots
center - list-like of form (xcen, ycen) containing the center of the spot pattern
ref_mask - np.ndarray of matched spots in reference image
src_mask - np.ndarray of matched spots in the data image
spot_sigma - sigma of a gaussian fit to a co-addition of detected spots
figures - dict of figures that are optionally produced
grid_fit - dict of best-fit parameters of grid fit used to do fine registration between source and reference spots
"""
data = check_wfsdata(data)
pup_mask = check_wfsdata(pup_mask)
if ref.pup_outer is None:
raise WFSConfigException("No pupil information applied to SH reference.")
pup_outer = ref.pup_outer
pup_inner = ref.pup_inner
# input data should be background subtracted for best results. this initial guess of the center positions
# will be good enough to get the central obscuration, but will need to be fine-tuned for aperture association.
xcen, ycen, pupcen_fig = center_pupil(data, pup_mask, threshold=cen_thresh, sigma=cen_sigma, plot=plot)
if np.hypot(xcen-cen[0], ycen-cen[1]) > cen_tol:
msg = f"Measured pupil center [{round(xcen)}, {round(ycen)}] more than {cen_tol} pixels from {cen}."
raise WFSAnalysisFailed(value=msg)
# using the mean spacing is straightforward for square apertures and a reasonable underestimate for hexagonal ones
ref_spacing = np.mean([ref.xspacing, ref.yspacing])
apsize = ref_spacing
srcs, masks, snrs, sigma, wfsfind_fig = get_apertures(data, apsize, fwhm=fwhm, thresh=thresh, cen=(xcen, ycen))
# ignore low S/N spots
srcs = srcs[snrs > spot_snr_thresh]
# get grid spacing of the data
xspacing, yspacing = grid_spacing(data, srcs)
# find the scale difference between data and ref and use as init
init_scale = (xspacing/ref.xspacing + yspacing/ref.yspacing) / 2.
# apply masking to detected sources to avoid partially illuminated apertures at the edges
srcs['dist'] = np.sqrt((srcs['xcentroid'] - xcen)**2 + (srcs['ycentroid'] - ycen)**2)
srcs = srcs[(srcs['dist'] > pup_inner*init_scale) & (srcs['dist'] < pup_outer*init_scale)]
# if we don't detect spots in at least half of the reference apertures, we can't usually get a good wavefront measurement
if len(srcs) < 0.5 * len(ref.masked_apertures['xcentroid']):
msg = "Only %d spots detected out of %d apertures." % (len(srcs), len(ref.masked_apertures['xcentroid']))
raise WFSAnalysisFailed(value=msg)
src_aps = photutils.CircularAperture(
list(zip(srcs['xcentroid'], srcs['ycentroid'])),
r=apsize/2.
)
# set up to do a fit of the reference apertures to the spot positions with the center, scaling, and position-dependent
# scaling (coma) as free parameters
args = (ref.masked_apertures, srcs)
par_keys = ('xcen', 'ycen', 'scale', 'xcoma', 'ycoma')
pars = (xcen, ycen, init_scale, 0.0, 0.0)
coma_bound = 1e-4 # keep coma constrained by now since it can cause trouble
# scipy.optimize.minimize can do bounded minimization so leverage that to keep the solution within a reasonable range.
bounds = (
(xcen-15, xcen+15), # hopefully we're not too far off from true center...
(ycen-15, ycen+15),
(init_scale-0.05, init_scale+0.05), # reasonable range of expected focus difference...
(-coma_bound, coma_bound),
(-coma_bound, coma_bound)
)
try:
min_results = optimize.minimize(fit_apertures, pars, args=args, bounds=bounds, options={'ftol': 1e-13, 'gtol': 1e-7})
except Exception as e:
msg = f"Aperture grid matching failed: {e}"
raise WFSAnalysisFailed(value=msg)
fit_results = {}
for i, k in enumerate(par_keys):
fit_results[k] = min_results['x'][i]
# this is more reliably the center of the actual pupil image whereas fit_results shifts a bit depending on detected spots.
# the lenslet pattern can move around a bit on the pupil, but we need the center of the pupil to calculate their pupil
# coordinates.
pup_center = [xcen, ycen]
scale = fit_results['scale']
xcoma, ycoma = fit_results['xcoma'], fit_results['ycoma']
refx = ref.masked_apertures['xcentroid'] * (scale + ref.masked_apertures['xcentroid'] * xcoma) + fit_results['xcen']
refy = ref.masked_apertures['ycentroid'] * (scale + ref.masked_apertures['ycentroid'] * ycoma) + fit_results['ycen']
xspacing = scale * ref.xspacing
yspacing = scale * ref.yspacing
# coarse match reference apertures to spots
spacing = np.max([xspacing, yspacing])
ref_mask, src_mask = match_apertures(refx, refy, srcs['xcentroid'], srcs['ycentroid'], max_dist=spacing/2.)
# these are unscaled so that the slope includes defocus
trim_refx = ref.masked_apertures['xcentroid'][ref_mask] + fit_results['xcen']
trim_refy = ref.masked_apertures['ycentroid'][ref_mask] + fit_results['ycen']
ref_aps = photutils.CircularAperture(
list(zip(trim_refx, trim_refy)),
r=ref_spacing/2.
)
slope_x = srcs['xcentroid'][src_mask] - trim_refx
slope_y = srcs['ycentroid'][src_mask] - trim_refy
pup_coords = (ref_aps.positions - pup_center) / [pup_outer, pup_outer]
aps_fig = None
if plot:
norm = wfs_norm(data)
aps_fig, ax = plt.subplots()
aps_fig.set_label("Aperture Positions")
ax.imshow(data, cmap='Greys', origin='lower', norm=norm, interpolation='None')
ax.scatter(pup_center[0], pup_center[1])
src_aps.plot(color='blue', axes=ax)
# need full slopes array the size of the complete set of reference apertures and pre-filled with np.nan for masking
slopes = np.nan * np.ones((2, len(ref.masked_apertures['xcentroid'])))
slopes[0][ref_mask] = slope_x
slopes[1][ref_mask] = slope_y
figures = {}
figures['pupil_center'] = pupcen_fig
figures['slopes'] = aps_fig
results = {
"slopes": np.ma.masked_invalid(slopes),
"pup_coords": pup_coords.transpose(),
"spots": srcs,
"src_aps": src_aps,
"spacing": (xspacing, yspacing),
"center": pup_center,
"ref_mask": ref_mask,
"src_mask": src_mask,
"spot_sigma": sigma,
"figures": figures,
"grid_fit": fit_results
}
return results
def make_init_pars(nmodes=21, modestart=2, init_zv=None):
"""
Make a set of initial parameters that can be used with `~lmfit.minimize` to make a wavefront fit with
parameter names that are compatible with ZernikeVectors.
Parameters
----------
nmodes: int (default: 21)
Number of Zernike modes to fit.
modestart: int (default: 2)
First Zernike mode to be used.
init_zv: ZernikeVector (default: None)
ZernikeVector containing initial values for the fit.
Returns
-------
params: `~lmfit.Parameters` instance
Initial parameters in form that can be passed to `~lmfit.minimize`.
"""
pars = []
for i in range(modestart, modestart+nmodes, 1):
key = "Z{:02d}".format(i)
if init_zv is not None:
val = init_zv[key].value
if val < 2. * np.finfo(float).eps:
val = 0.0
else:
val = 0.0
zpar = (key, val)
pars.append(zpar)
params = lmfit.Parameters()
params.add_many(*pars)
return params
def slope_diff(pars, coords, slopes, norm=False):
"""
For a given set of wavefront fit parameters, calculate the "distance" between the predicted and measured wavefront
slopes. This function is used by `~lmfit.minimize` which expects the sqrt to be applied rather than a chi-squared,
"""
parsdict = pars.valuesdict()
rho, phi = cart2pol(coords)
xslope = slopes[0]
yslope = slopes[1]
pred_xslope, pred_yslope = zernike_slopes(parsdict, rho, phi, norm=norm)
dist = np.sqrt((xslope - pred_xslope)**2 + (yslope - pred_yslope)**2)
return dist
class SH_Reference(object):
"""
Class to handle Shack-Hartmann reference data
"""
def __init__(self, data, fwhm=4.5, threshold=20.0, plot=True):
"""
Read WFS reference image and generate reference magnifications (i.e. grid spacing) and
aperture positions.
Parameters
----------
data : FITS filename or 2D ndarray
WFS reference image
fwhm : float
FWHM in pixels of DAOfind convolution kernel
threshold : float
DAOfind threshold in units of the standard deviation of the image
plot : bool
Toggle plotting of the reference image and overlayed apertures
"""
self.data = check_wfsdata(data)
data = data - np.median(data)
self.apertures, self.figure = wfsfind(data, fwhm=fwhm, threshold=threshold, plot=plot)
if plot:
self.figure.set_label("Reference Image")
self.xcen = self.apertures['xcentroid'].mean()
self.ycen = self.apertures['ycentroid'].mean()
self.xspacing, self.yspacing = grid_spacing(data, self.apertures)
# make masks for each reference spot and fit a 2D gaussian to get its FWHM. the reference FWHM is subtracted in
# quadrature from the observed FWHM when calculating the seeing.
apsize = np.mean([self.xspacing, self.yspacing])
apers = photutils.CircularAperture(
list(zip(self.apertures['xcentroid'], self.apertures['ycentroid'])),
r=apsize/2.
)
masks = apers.to_mask(method='subpixel')
self.photapers = apers
self.spot = np.zeros(masks[0].shape)
for m in masks:
subim = m.cutout(data)
# make co-added spot image for use in calculating the seeing
if subim.shape == self.spot.shape:
self.spot += subim
self.apertures['xcentroid'] -= self.xcen
self.apertures['ycentroid'] -= self.ycen
self.apertures['dist'] = np.sqrt(self.apertures['xcentroid']**2 + self.apertures['ycentroid']**2)
self.masked_apertures = self.apertures
self.pup_inner = None
self.pup_outer = None
def adjust_center(self, x, y):
"""
Adjust reference center to new x, y position.
"""
self.apertures['xcentroid'] += self.xcen
self.apertures['ycentroid'] += self.ycen
self.apertures['xcentroid'] -= x
self.apertures['ycentroid'] -= y
self.apertures['dist'] = np.sqrt(self.apertures['xcentroid']**2 + self.apertures['ycentroid']**2)
self.xcen = x
self.ycen = y
self.apply_pupil(self.pup_inner, self.pup_outer)
def apply_pupil(self, pup_inner, pup_outer):
"""
Apply a pupil mask to the reference apertures
"""
if pup_inner is not None and pup_outer is not None:
self.masked_apertures = self.apertures[(self.apertures['dist'] > pup_inner) & (self.apertures['dist'] < pup_outer)]
self.pup_inner = pup_inner
self.pup_outer = pup_outer
def pup_coords(self, pup_outer):
"""
Take outer radius of pupil and calculate pupil coordinates for the masked apertures
"""
coords = (self.masked_apertures['xcentroid']/pup_outer, self.masked_apertures['ycentroid']/pup_outer)
return coords
def WFSFactory(wfs="f5", config={}, **kwargs):
"""
Build and return proper WFS sub-class instance based on the value of 'wfs'.
"""
config = merge_config(config, dict(**kwargs))
wfs = wfs.lower()
types = recursive_subclasses(WFS)
wfses = [t.__name__.lower() for t in types]
wfs_map = dict(list(zip(wfses, types)))
if wfs not in wfses:
raise WFSConfigException(value="Specified WFS, %s, not valid or not implemented." % wfs)
if 'plot' in config:
plot = config['plot']
else:
plot = True
wfs_cls = wfs_map[wfs](config=config, plot=plot)
return wfs_cls
class WFS(object):
"""
Defines configuration pattern and methods common to all WFS systems
"""
def __init__(self, config={}, plot=True, **kwargs):
key = self.__class__.__name__.lower()
self.__dict__.update(merge_config(mmtwfs_config['wfs'][key], config))
self.telescope = TelescopeFactory(telescope=self.telescope, secondary=self.secondary)
self.secondary = self.telescope.secondary
self.plot = plot
self.connected = False
self.ref_fwhm = self.ref_spot_fwhm()
# this factor calibrates spot motion in pixels to nm of wavefront error
self.tiltfactor = self.telescope.nmperasec * (self.pix_size.to(u.arcsec).value)
# if this is the same for all modes, load it once here
if hasattr(self, "reference_file"):
refdata, hdr = check_wfsdata(self.reference_file, header=True)
refdata = self.trim_overscan(refdata, hdr)
reference = SH_Reference(refdata, plot=self.plot)
# now assign 'reference' for each mode so that it can be accessed consistently in all cases
for mode in self.modes:
if 'reference_file' in self.modes[mode]:
refdata, hdr = check_wfsdata(self.modes[mode]['reference_file'], header=True)
refdata = self.trim_overscan(refdata, hdr)
self.modes[mode]['reference'] = SH_Reference(
refdata,
plot=self.plot
)
else:
self.modes[mode]['reference'] = reference
def ref_spot_fwhm(self):
"""
Calculate the Airy FWHM in pixels of a perfect WFS spot from the optical prescription and detector pixel size
"""
theta_fwhm = 1.028 * self.eff_wave / self.lenslet_pitch
det_fwhm = np.arctan(theta_fwhm).value * self.lenslet_fl
det_fwhm_pix = det_fwhm.to(u.um).value / self.pix_um.to(u.um).value
return det_fwhm_pix
def get_flipud(self, mode=None):
"""
Determine if the WFS image needs to be flipped up/down
"""
return False
def get_fliplr(self, mode=None):
"""
Determine if the WFS image needs to be flipped left/right
"""
return False
def ref_pupil_location(self, mode, hdr=None):
"""
Get the center of the pupil on the reference image
"""
ref = self.modes[mode]['reference']
x = ref.xcen
y = ref.ycen
return x, y
def seeing(self, mode, sigma, airmass=None):
"""
Given a sigma derived from a gaussian fit to a WFS spot, deconvolve the systematic width from the reference image
and relate the remainder to r_0 and thus a seeing FWHM.
"""
# the effective wavelength of the WFS imagers is about 600-700 nm. mmirs and the oldf9 system use blue-blocking filters
wave = self.eff_wave
wave = wave.to(u.m).value # r_0 equation expects meters so convert
refwave = 500 * u.nm # standard wavelength that seeing values are referenced to
refwave = refwave.to(u.m).value
# calculate the physical size of each aperture.
ref = self.modes[mode]['reference']
apsize_pix = np.max((ref.xspacing, ref.yspacing))
d = self.telescope.diameter * apsize_pix / self.pup_size
d = d.to(u.m).value # r_0 equation expects meters so convert
# we need to deconvolve the instrumental spot width from the measured one to get the portion of the width that
# is due to spot motion
ref_sigma = stats.funcs.gaussian_fwhm_to_sigma * self.ref_fwhm
if sigma > ref_sigma:
corr_sigma = np.sqrt(sigma**2 - ref_sigma**2)
else:
return 0.0 * u.arcsec, 0.0 * u.arcsec
corr_sigma *= self.pix_size.to(u.rad).value # r_0 equation expects radians so convert
# this equation relates the motion within a single aperture to the characteristic scale size of the
# turbulence, r_0.
r_0 = (0.179 * (wave**2) * (d**(-1/3))/corr_sigma**2)**0.6
# this equation relates the turbulence scale size to an expected image FWHM at the given wavelength.
raw_seeing = u.Quantity(u.rad * 0.98 * wave / r_0, u.arcsec)
# seeing scales as lambda^-1/5 so calculate factor to scale to reference lambda
wave_corr = refwave**-0.2 / wave**-0.2
raw_seeing *= wave_corr
# correct seeing to zenith
if airmass is not None:
seeing = raw_seeing / airmass**0.6
else:
seeing = raw_seeing
return seeing, raw_seeing
def pupil_mask(self, hdr=None):
"""
Load and return the WFS spot mask used to locate and register the pupil
"""
pup_mask = check_wfsdata(self.wfs_mask)
return pup_mask
def reference_aberrations(self, mode, **kwargs):
"""
Create reference ZernikeVector for 'mode'.
"""
z = ZernikeVector(**self.modes[mode]['ref_zern'])
return z
def get_mode(self, hdr):
"""
If mode is not specified, either set it to the default mode or figure out the mode from the header.
"""
mode = self.default_mode
return mode
def process_image(self, fitsfile):
"""
Process the image to make it suitable for accurate wavefront analysis. Steps include nuking cosmic rays,
subtracting background, handling overscan regions, etc.
"""
rawdata, hdr = check_wfsdata(fitsfile, header=True)
trimdata = self.trim_overscan(rawdata, hdr=hdr)
# MMIRS gets a lot of hot pixels/CRs so make a quick pass to nuke them
cr_mask, data = detect_cosmics(trimdata, sigclip=5., niter=5, cleantype='medmask', psffwhm=5.)
# calculate the background and subtract it
bkg_estimator = photutils.ModeEstimatorBackground()
mask = photutils.make_source_mask(data, nsigma=2, npixels=5, dilate_size=11)
bkg = photutils.Background2D(data, (10, 10), filter_size=(5, 5), bkg_estimator=bkg_estimator, mask=mask)
data -= bkg.background
return data, hdr
def trim_overscan(self, data, hdr=None):
"""
Use the DATASEC in the header to determine the region to trim out. If no header provided or if the header
doesn't contain DATASEC, return data unchanged.
"""
if hdr is None:
return data
if 'DATASEC' not in hdr:
# if no DATASEC in header, punt and return unchanged
return data
datasec = slice_from_string(hdr['DATASEC'], fits_convention=True)
return data[datasec]
def measure_slopes(self, fitsfile, mode=None, plot=True, flipud=False, fliplr=False):
"""
Take a WFS image in FITS format, perform background subtration, pupil centration, and then use get_slopes()
to perform the aperture placement and spot centroiding.
"""
data, hdr = self.process_image(fitsfile)
plot = plot and self.plot
# flip data up/down if we need to. only binospec needs to currently.
if flipud or self.get_flipud(mode=mode):
data = np.flipud(data)
# flip left/right if we need to. no mode currently does, but who knows what the future holds.
if fliplr or self.get_fliplr(mode=mode):
data = np.fliplr(data)
if mode is None:
mode = self.get_mode(hdr)
if mode not in self.modes:
msg = "Invalid mode, %s, for WFS system, %s." % (mode, self.__class__.__name__)
raise WFSConfigException(value=msg)
# if available, get the rotator angle out of the header
if 'ROT' in hdr:
rotator = hdr['ROT'] * u.deg
else:
rotator = 0.0 * u.deg
# if there's a ROTOFF in the image header, grab it and adjust the rotator angle accordingly
if 'ROTOFF' in hdr:
rotator -= hdr['ROTOFF'] * u.deg
# make mask for finding wfs spot pattern
pup_mask = self.pupil_mask(hdr=hdr)
# get adjusted reference center position and update the reference
xcen, ycen = self.ref_pupil_location(mode, hdr=hdr)
self.modes[mode]['reference'].adjust_center(xcen, ycen)
# apply pupil to the reference
self.modes[mode]['reference'].apply_pupil(self.pup_inner, self.pup_size/2.)
ref_zv = self.reference_aberrations(mode, hdr=hdr)
zref = ref_zv.array
if len(zref) < self.nzern:
pad = np.zeros(self.nzern - len(zref))
zref = np.hstack((zref, pad))
try:
slope_results = get_slopes(
data,
self.modes[mode]['reference'],
pup_mask,
fwhm=self.find_fwhm,
thresh=self.find_thresh,
cen=self.cor_coords,
cen_thresh=self.cen_thresh,
cen_sigma=self.cen_sigma,
cen_tol=self.cen_tol,
plot=plot
)
slopes = slope_results['slopes']
coords = slope_results['pup_coords']
ref_pup_coords = self.modes[mode]['reference'].pup_coords(self.pup_size/2.)
rho, phi = cart2pol(ref_pup_coords)
ref_slopes = -(1. / self.tiltfactor) * np.array(zernike_slopes(ref_zv, rho, phi))
aps = slope_results['src_aps']
ref_mask = slope_results['ref_mask']
src_mask = slope_results['src_mask']
figures = slope_results['figures']
except WFSAnalysisFailed as e:
log.warning(f"Wavefront slope measurement failed: {e}")
slope_fig = None
if plot:
slope_fig, ax = plt.subplots()
slope_fig.set_label("WFS Image")
norm = wfs_norm(data)
ax.imshow(data, cmap='Greys', origin='lower', norm=norm, interpolation='None')
results = {}
results['slopes'] = None
results['figures'] = {}
results['mode'] = mode
results['figures']['slopes'] = slope_fig
return results
except Exception as e:
raise WFSAnalysisFailed(value=str(e))
# use the average width of the spots to estimate the seeing and use the airmass to extrapolate to zenith seeing
if 'AIRMASS' in hdr:
airmass = hdr['AIRMASS']
else:
airmass = None
seeing, raw_seeing = self.seeing(mode=mode, sigma=slope_results['spot_sigma'], airmass=airmass)
if plot:
sub_slopes = slopes - ref_slopes
x = aps.positions.transpose()[0][src_mask]
y = aps.positions.transpose()[1][src_mask]
uu = sub_slopes[0][ref_mask]
vv = sub_slopes[1][ref_mask]
norm = wfs_norm(data)
figures['slopes'].set_label("Aperture Positions and Spot Movement")
ax = figures['slopes'].axes[0]
ax.imshow(data, cmap='Greys', origin='lower', norm=norm, interpolation='None')
aps.plot(color='blue', axes=ax)
ax.quiver(x, y, uu, vv, scale_units='xy', scale=0.2, pivot='tip', color='red')
xl = [0.1*data.shape[1]]
yl = [0.95*data.shape[0]]
ul = [1.0/self.pix_size.value]
vl = [0.0]
ax.quiver(xl, yl, ul, vl, scale_units='xy', scale=0.2, pivot='tip', color='red')
ax.scatter([slope_results['center'][0]], [slope_results['center'][1]])
ax.text(0.12*data.shape[1], 0.95*data.shape[0], "1{0:unicode}".format(u.arcsec), verticalalignment='center')
ax.set_title("Seeing: %.2f\" (%.2f\" @ zenith)" % (raw_seeing.value, seeing.value))
results = {}
results['seeing'] = seeing
results['raw_seeing'] = raw_seeing
results['slopes'] = slopes
results['ref_slopes'] = ref_slopes
results['ref_zv'] = ref_zv
results['spots'] = slope_results['spots']
results['pup_coords'] = coords
results['ref_pup_coords'] = ref_pup_coords
results['apertures'] = aps
results['xspacing'] = slope_results['spacing'][0]
results['yspacing'] = slope_results['spacing'][1]
results['xcen'] = slope_results['center'][0]
results['ycen'] = slope_results['center'][1]
results['pup_mask'] = pup_mask
results['data'] = data
results['header'] = hdr
results['rotator'] = rotator
results['mode'] = mode
results['ref_mask'] = ref_mask
results['src_mask'] = src_mask
results['fwhm'] = stats.funcs.gaussian_sigma_to_fwhm * slope_results['spot_sigma']
results['figures'] = figures
results['grid_fit'] = slope_results['grid_fit']
return results
def fit_wavefront(self, slope_results, plot=True):
"""
Use results from self.measure_slopes() to fit a set of zernike polynomials to the wavefront shape.
"""
plot = plot and self.plot
if slope_results['slopes'] is not None:
results = {}
slopes = -self.tiltfactor * slope_results['slopes']
coords = slope_results['ref_pup_coords']
rho, phi = cart2pol(coords)
zref = slope_results['ref_zv']
params = make_init_pars(nmodes=self.nzern, init_zv=zref)
results['fit_report'] = lmfit.minimize(slope_diff, params, args=(coords, slopes))
zfit = ZernikeVector(coeffs=results['fit_report'])
results['raw_zernike'] = zfit
# derotate the zernike solution to match the primary mirror coordinate system
total_rotation = self.rotation - slope_results['rotator']
zv_rot = ZernikeVector(coeffs=results['fit_report'])
zv_rot.rotate(angle=-total_rotation)
results['rot_zernike'] = zv_rot
# subtract the reference aberrations
zsub = zv_rot - zref
results['ref_zernike'] = zref
results['zernike'] = zsub
pred_slopes = np.array(zernike_slopes(zfit, rho, phi))
diff = slopes - pred_slopes
diff_pix = diff / self.tiltfactor
rms = np.sqrt((diff[0]**2 + diff[1]**2).mean())
results['residual_rms_asec'] = rms / self.telescope.nmperasec * u.arcsec
results['residual_rms'] = rms * zsub.units
results['zernike_rms'] = zsub.rms
results['zernike_p2v'] = zsub.peak2valley
fig = None
if plot:
ref_mask = slope_results['ref_mask']
src_mask = slope_results['src_mask']
im = slope_results['data']
gnorm = wfs_norm(im)
fig, ax = plt.subplots()
fig.set_label("Zernike Fit Residuals")
ax.imshow(im, cmap='Greys', origin='lower', norm=gnorm, interpolation='None')
x = slope_results['apertures'].positions.transpose()[0][src_mask]
y = slope_results['apertures'].positions.transpose()[1][src_mask]
ax.quiver(x, y, diff_pix[0][ref_mask], diff_pix[1][ref_mask], scale_units='xy',
scale=0.05, pivot='tip', color='red')
xl = [0.1*im.shape[1]]
yl = [0.95*im.shape[0]]
ul = [0.2/self.pix_size.value]
vl = [0.0]
ax.quiver(xl, yl, ul, vl, scale_units='xy', scale=0.05, pivot='tip', color='red')
ax.text(0.12*im.shape[1], 0.95*im.shape[0], "0.2{0:unicode}".format(u.arcsec), verticalalignment='center')
ax.text(
0.95*im.shape[1],
0.95*im.shape[0],
"Residual RMS: {0.value:0.2f}{0.unit:unicode}".format(results['residual_rms_asec']),
verticalalignment='center',
horizontalalignment='right'
)
iq = np.sqrt(results['residual_rms_asec']**2 +
(results['zernike_rms'].value / self.telescope.nmperasec * u.arcsec)**2)
ax.set_title("Image Quality: {0.value:0.2f}{0.unit:unicode}".format(iq))
results['resid_plot'] = fig
else:
results = None
return results
def calculate_primary(self, zv, threshold=0.0 * u.nm, mask=[]):
"""
Calculate force corrections to primary mirror and any required focus offsets. Use threshold to determine which
terms in 'zv' to use in the force calculations. Any terms with normalized amplitude less than threshold will
not be used in the force calculation. In addition, individual terms can be forced to be masked.
"""
zv.denormalize()
zv_masked = ZernikeVector()
zv_norm = zv.copy()
zv_norm.normalize()
log.debug(f"thresh: {threshold} mask {mask}")
for z in zv:
if abs(zv_norm[z]) >= threshold:
zv_masked[z] = zv[z]
log.debug(f"{z}: Good")
else:
log.debug(f"{z}: Bad")
zv_masked.denormalize() # need to assure we're using fringe coeffs
log.debug(f"\nInput masked: {zv_masked}")
# use any available error bars to mask down to 1 sigma below amplitude or 0 if error bars are larger than amplitude.
for z in zv_masked:
frac_err = 1. - min(zv_masked.frac_error(key=z), 1.)
zv_masked[z] *= frac_err
log.debug(f"\nErrorbar masked: {zv_masked}")
forces, m1focus, zv_allmasked = self.telescope.calculate_primary_corrections(
zv=zv_masked,
mask=mask,
gain=self.m1_gain
)
log.debug(f"\nAll masked: {zv_allmasked}")
return forces, m1focus, zv_allmasked
def calculate_focus(self, zv):
"""
Convert Zernike defocus to um of secondary offset.
"""
z_denorm = zv.copy()
z_denorm.denormalize() # need to assure we're using fringe coeffs
frac_err = 1. - min(z_denorm.frac_error(key='Z04'), 1.)
foc_corr = -self.m2_gain * frac_err * z_denorm['Z04'] / self.secondary.focus_trans
return foc_corr.round(2)
def calculate_cc(self, zv):
"""
Convert Zernike coma (Z07 and Z08) into arcsec of secondary center-of-curvature tilts.
"""
z_denorm = zv.copy()
z_denorm.denormalize() # need to assure we're using fringe coeffs
# fix coma using tilts around the M2 center of curvature.
y_frac_err = 1. - min(z_denorm.frac_error(key='Z07'), 1.)
x_frac_err = 1. - min(z_denorm.frac_error(key='Z08'), 1.)
cc_y_corr = -self.m2_gain * y_frac_err * z_denorm['Z07'] / self.secondary.theta_cc
cc_x_corr = -self.m2_gain * x_frac_err * z_denorm['Z08'] / self.secondary.theta_cc
return cc_x_corr.round(3), cc_y_corr.round(3)
def calculate_recenter(self, fit_results, defoc=1.0):
"""
Perform zero-coma hexapod tilts to align the pupil center to the center-of-rotation.
The location of the CoR is configured to be at self.cor_coords.
"""
xc = fit_results['xcen']
yc = fit_results['ycen']
xref = self.cor_coords[0]
yref = self.cor_coords[1]
dx = xc - xref
dy = yc - yref
total_rotation = u.Quantity(self.rotation - fit_results['rotator'], u.rad).value
dr, phi = cart2pol([dx, dy])
derot_phi = phi + total_rotation
az, el = pol2cart([dr, derot_phi])
az *= self.az_parity * self.pix_size * defoc # pix size scales with the pupil size as focus changes.
el *= self.el_parity * self.pix_size * defoc
return az.round(3), el.round(3)
def clear_m1_corrections(self):
"""
Clear corrections applied to the primary mirror. This includes the 'm1spherical' offsets sent to the secondary.
"""
log.info("Clearing WFS corrections from M1 and m1spherical offsets from M2.")
clear_forces, clear_m1focus = self.telescope.clear_forces()
return clear_forces, clear_m1focus
def clear_m2_corrections(self):
"""
Clear corrections sent to the secondary mirror, specifically the 'wfs' offsets.
"""
log.info("Clearing WFS offsets from M2's hexapod.")
cmds = self.secondary.clear_wfs()
return cmds
def clear_corrections(self):
"""
Clear all applied WFS corrections
"""
forces, m1focus = self.clear_m1_corrections()
cmds = self.clear_m2_corrections()
return forces, m1focus, cmds
def connect(self):
"""
Set state to connected
"""
self.telescope.connect()
self.secondary.connect()
if self.telescope.connected and self.secondary.connected:
self.connected = True
else:
self.connected = False
def disconnect(self):
"""
Set state to disconnected
"""
self.telescope.disconnect()
self.secondary.disconnect()
self.connected = False
class F9(WFS):
"""
Defines configuration and methods specific to the F/9 WFS system
"""
def __init__(self, config={}, plot=True):
super(F9, self).__init__(config=config, plot=plot)
self.connected = False
# set up CompMirror object
self.compmirror = CompMirror()
def connect(self):
"""
Run parent connect() method and then connect to the topbox if we can connect to the rest.
"""
super(F9, self).connect()
if self.connected:
self.compmirror.connect()
def disconnect(self):
"""
Run parent disconnect() method and then disconnect the topbox
"""
super(F9, self).disconnect()
self.compmirror.disconnect()
class NewF9(F9):
"""
Defines configuration and methods specific to the F/9 WFS system with the new SBIG CCD
"""
def process_image(self, fitsfile):
"""
Process the image to make it suitable for accurate wavefront analysis. Steps include nuking cosmic rays,
subtracting background, handling overscan regions, etc.
"""
rawdata, hdr = check_wfsdata(fitsfile, header=True)
cr_mask, data = detect_cosmics(rawdata, sigclip=15., niter=5, cleantype='medmask', psffwhm=10.)
# calculate the background and subtract it
bkg_estimator = photutils.ModeEstimatorBackground()
mask = photutils.make_source_mask(data, nsigma=2, npixels=7, dilate_size=13)
bkg = photutils.Background2D(data, (50, 50), filter_size=(15, 15), bkg_estimator=bkg_estimator, mask=mask)
data -= bkg.background
return data, hdr
class F5(WFS):
"""
Defines configuration and methods specific to the F/5 WFS systems
"""
def __init__(self, config={}, plot=True):
super(F5, self).__init__(config=config, plot=plot)
self.connected = False
self.sock = None
# load lookup table for off-axis aberrations
self.aberr_table = ascii.read(self.aberr_table_file)
def process_image(self, fitsfile):
"""
Process the image to make it suitable for accurate wavefront analysis. Steps include nuking cosmic rays,
subtracting background, handling overscan regions, etc.
"""
rawdata, hdr = check_wfsdata(fitsfile, header=True)
trimdata = self.trim_overscan(rawdata, hdr=hdr)
cr_mask, data = detect_cosmics(trimdata, sigclip=15., niter=5, cleantype='medmask', psffwhm=10.)
# calculate the background and subtract it
bkg_estimator = photutils.ModeEstimatorBackground()
mask = photutils.make_source_mask(data, nsigma=2, npixels=5, dilate_size=11)
bkg = photutils.Background2D(data, (20, 20), filter_size=(10, 10), bkg_estimator=bkg_estimator, mask=mask)
data -= bkg.background
return data, hdr
def ref_pupil_location(self, mode, hdr=None):
"""
For now we set the F/5 wfs center by hand based on engineering data. Should determine this more carefully.
"""
x = 262.0
y = 259.0
return x, y
def focal_plane_position(self, hdr):
"""
Need to fill this in for the hecto f/5 WFS system. For now will assume it's always on-axis.
"""
return 0.0 * u.deg, 0.0 * u.deg
def calculate_recenter(self, fit_results, defoc=1.0):
"""
Perform zero-coma hexapod tilts to align the pupil center to the center-of-rotation.
The location of the CoR is configured to be at self.cor_coords.
"""
xc = fit_results['xcen']
yc = fit_results['ycen']
xref = self.cor_coords[0]
yref = self.cor_coords[1]
dx = xc - xref
dy = yc - yref
cam_rotation = self.rotation - 90 * u.deg # pickoff plus fold mirror makes a 90 deg rotation
total_rotation = u.Quantity(cam_rotation - fit_results['rotator'], u.rad).value
dr, phi = cart2pol([dx, -dy]) # F/5 camera needs an up/down flip
derot_phi = phi + total_rotation
az, el = pol2cart([dr, derot_phi])
az *= self.az_parity * self.pix_size * defoc # pix size scales with the pupil size as focus changes.
el *= self.el_parity * self.pix_size * defoc
return az.round(3), el.round(3)
def reference_aberrations(self, mode, hdr=None):
"""
Create reference ZernikeVector for 'mode'. Pass 'hdr' to self.focal_plane_position() to get position of
the WFS when the data was acquired.
"""
# for most cases, this gets the reference focus
z_default = ZernikeVector(**self.modes[mode]['ref_zern'])
# now get the off-axis aberrations
z_offaxis = ZernikeVector()
if hdr is None:
log.warning("Missing WFS header. Assuming data is acquired on-axis.")
field_r = 0.0 * u.deg
field_phi = 0.0 * u.deg
else:
field_r, field_phi = self.focal_plane_position(hdr)
# ignore piston and x/y tilts
for i in range(4, 12):
k = "Z%02d" % i
z_offaxis[k] = np.interp(field_r.to(u.deg).value, self.aberr_table['field_r'], self.aberr_table[k]) * u.um
# remove the 90 degree offset between the MMT and zernike conventions and then rotate the offaxis aberrations
z_offaxis.rotate(angle=field_phi - 90. * u.deg)
z = z_default + z_offaxis
return z
class Binospec(F5):
"""
Defines configuration and methods specific to the Binospec WFS system. Binospec uses the same aberration table
as the F5 system so we inherit from that.
"""
def get_flipud(self, mode):
"""
Method to determine if the WFS image needs to be flipped up/down
During the first binospec commissioning run the images were flipped u/d as they came in. Since then, they are
left as-is and get flipped internally based on this flag. The reference file is already flipped.
"""
return True
def ref_pupil_location(self, mode, hdr=None):
"""
If a header is passed in, use Jan Kansky's linear relations to get the pupil center on the reference image.
Otherwise, use the default method.
"""
if hdr is None:
ref = self.modes[mode]['reference']
x = ref.xcen
y = ref.ycen
else:
for k in ['STARXMM', 'STARYMM']:
if k not in hdr:
# we'll be lenient for now with missing header info. if not provided, assume we're on-axis.
msg = f"Missing value, {k}, that is required to transform Binospec guider coordinates. Defaulting to 0.0."
log.warning(msg)
hdr[k] = 0.0
y = 232.771 + 0.17544 * hdr['STARXMM']
x = 265.438 + -0.20406 * hdr['STARYMM'] + 12.0
return x, y
def focal_plane_position(self, hdr):
"""
Transform from the Binospec guider coordinate system to MMTO focal plane coordinates.
"""
for k in ['ROT', 'STARXMM', 'STARYMM']:
if k not in hdr:
# we'll be lenient for now with missing header info. if not provided, assume we're on-axis.
msg = f"Missing value, {k}, that is required to transform Binospec guider coordinates. Defaulting to 0.0."
log.warning(msg)
hdr[k] = 0.0
guide_x = hdr['STARXMM']
guide_y = hdr['STARYMM']
rot = hdr['ROT']
guide_r = np.sqrt(guide_x**2 + guide_y**2) * u.mm
rot = u.Quantity(rot, u.deg) # make sure rotation is cast to degrees
# the MMTO focal plane coordinate convention has phi=0 aligned with +Y instead of +X
if guide_y != 0.0:
guide_phi = np.arctan2(guide_x, guide_y) * u.rad
else:
guide_phi = 90. * u.deg
# transform radius in guider coords to degrees in focal plane
focal_r = (guide_r / self.secondary.plate_scale).to(u.deg)
focal_phi = guide_phi + rot + self.rotation
log.debug(f"guide_phi: {guide_phi.to(u.rad)} rot: {rot}")
return focal_r, focal_phi
def in_wfs_region(self, xw, yw, x, y):
"""
Determine if a position is within the region available to Binospec's WFS
"""
return True # placekeeper until the optical prescription is implemented
def pupil_mask(self, hdr, npts=14):
"""
Generate a synthetic pupil mask
"""
if hdr is not None:
x_wfs = hdr.get('STARXMM', 150.0)
y_wfs = hdr.get('STARYMM', 0.0)
else:
x_wfs = 150.0
y_wfs = 0.0
log.warning("Header information not available for Binospec pupil mask. Assuming default position.")
good = []
center = self.pup_size / 2.
obsc = self.telescope.obscuration.value
spacing = 2.0 / npts
for x in np.arange(-1, 1, spacing):
for y in np.arange(-1, 1, spacing):
r = np.hypot(x, y)
if (r < 1 and np.hypot(x, y) >= obsc):
if self.in_wfs_region(x_wfs, y_wfs, x, y):
x_impos = center * (x + 1.)
y_impos = center * (y + 1.)
amp = 1.
# this is kind of a hacky way to dim spots near the edge, but easier than doing full calc
# of the aperture intersection with pupil. it also doesn't need to be that accurate for the
# purposes of the cross-correlation used to register the pupil.
if r > 1. - spacing:
amp = 1. - (r - (1. - spacing)) / spacing
if r - obsc < spacing:
amp = (r - obsc) / spacing
good.append((amp, x_impos, y_impos))
yi, xi = np.mgrid[0:self.pup_size, 0:self.pup_size]
im = np.zeros((self.pup_size, self.pup_size))
sigma = 3.
for g in good:
im += Gaussian2D(g[0], g[1], g[2], sigma, sigma)(xi, yi)
# Measured by hand from reference LED image
cam_rot = 0.595
im_rot = rotate(im, cam_rot, reshape=False)
im_rot[im_rot < 1e-2] = 0.0
return im_rot
class MMIRS(F5):
"""
Defines configuration and methods specific to the MMIRS WFS system
"""
def __init__(self, config={}, plot=True):
super(MMIRS, self).__init__(config=config, plot=plot)
# Parameters describing MMIRS pickoff mirror geometry
# Location and diameter of exit pupil
# Determined by tracing chief ray at 7.2' field angle with mmirs_asbuiltoptics_20110107_corronly.zmx
self.zp = 71.749 / 0.02714
self.dp = self.zp / 5.18661 # Working f/# from Zemax file
# Location of fold mirror
self.zm = 114.8
# Angle of fold mirror
self.am = 42 * u.deg
# Following dimensions from drawing MMIRS-1233_Rev1.pdf
# Diameter of pickoff mirror
self.pickoff_diam = (6.3 * u.imperial.inch).to(u.mm).value
# X size of opening in pickoff mirror
self.pickoff_xsize = (3.29 * u.imperial.inch).to(u.mm).value
# Y size of opening in pickoff mirror
self.pickoff_ysize = (3.53 * u.imperial.inch).to(u.mm).value
# radius of corner in pickoff mirror
self.pickoff_rcirc = (0.4 * u.imperial.inch).to(u.mm).value
def mirrorpoint(self, x0, y0, x, y):
"""
Compute intersection of ray with pickoff mirror.
The ray leaves the exit pupil at position x,y and hits the focal surface at x0,y0.
Math comes from http://geomalgorithms.com/a05-_intersect-1.html
"""
# Point in focal plane
P0 = np.array([x0, y0, 0])
# Point in exit pupil
P1 = np.array([x * self.dp / 2, y * self.dp / 2, self.zp])
# Pickoff mirror intesection with optical axis
V0 = np.array([0, 0, self.zm])
# normal to mirror
if (x0 < 0):
n = np.array([-np.sin(self.am), 0, np.cos(self.am)])
else:
n = np.array([np.sin(self.am), 0, np.cos(self.am)])
w = P0 - V0
# Vector connecting P0 to P1
u = P1 - P0
# Distance from P0 to intersection as a fraction of abs(u)
s = -n.dot(w) / n.dot(u)
# Intersection point on mirror
P = P0 + s * u
return (P[0], P[1])
def onmirror(self, x, y, side):
"""
Determine if a point is on the pickoff mirror surface:
x,y = coordinates of ray
side=1 means right face of the pickoff mirror, -1=left face
"""
if np.hypot(x, y) > self.pickoff_diam / 2.:
return False
if x * side < 0:
return False
x = abs(x)
y = abs(y)
if ((x > self.pickoff_xsize/2) or (y > self.pickoff_ysize/2)
or (x > self.pickoff_xsize/2 - self.pickoff_rcirc and y > self.pickoff_ysize/2 - self.pickoff_rcirc
and np.hypot(x - (self.pickoff_xsize/2 - self.pickoff_rcirc),
y - (self.pickoff_ysize/2 - self.pickoff_rcirc)) > self.pickoff_rcirc)):
return True
else:
return False
def drawoutline(self, ax):
"""
Draw outline of MMIRS pickoff mirror onto matplotlib axis, ax
"""
circ = np.arange(360) * u.deg
ax.plot(np.cos(circ) * self.pickoff_diam/2, np.sin(circ) * self.pickoff_diam/2, "b")
ax.set_aspect('equal', 'datalim')
ax.plot(
[-(self.pickoff_xsize/2 - self.pickoff_rcirc), (self.pickoff_xsize/2 - self.pickoff_rcirc)],
[self.pickoff_ysize/2, self.pickoff_ysize/2],
"b"
)
ax.plot(
[-(self.pickoff_xsize/2 - self.pickoff_rcirc), (self.pickoff_xsize/2 - self.pickoff_rcirc)],
[-self.pickoff_ysize/2, -self.pickoff_ysize/2],
"b"
)
ax.plot(
[-(self.pickoff_xsize/2), -(self.pickoff_xsize/2)],
[self.pickoff_ysize/2 - self.pickoff_rcirc, -(self.pickoff_ysize/2 - self.pickoff_rcirc)],
"b"
)
ax.plot(
[(self.pickoff_xsize/2), (self.pickoff_xsize/2)],
[self.pickoff_ysize/2 - self.pickoff_rcirc, -(self.pickoff_ysize/2 - self.pickoff_rcirc)],
"b"
)
ax.plot(
np.cos(circ[0:90]) * self.pickoff_rcirc + self.pickoff_xsize/2 - self.pickoff_rcirc,
np.sin(circ[0:90]) * self.pickoff_rcirc + self.pickoff_ysize/2 - self.pickoff_rcirc,
"b"
)
ax.plot(
np.cos(circ[90:180]) * self.pickoff_rcirc - self.pickoff_xsize/2 + self.pickoff_rcirc,
np.sin(circ[90:180]) * self.pickoff_rcirc + self.pickoff_ysize/2 - self.pickoff_rcirc,
"b"
)
ax.plot(
np.cos(circ[180:270]) * self.pickoff_rcirc - self.pickoff_xsize/2 + self.pickoff_rcirc,
np.sin(circ[180:270]) * self.pickoff_rcirc - self.pickoff_ysize/2 + self.pickoff_rcirc,
"b"
)
ax.plot(
np.cos(circ[270:360]) * self.pickoff_rcirc + self.pickoff_xsize/2 - self.pickoff_rcirc,
np.sin(circ[270:360]) * self.pickoff_rcirc - self.pickoff_ysize/2 + self.pickoff_rcirc,
"b"
)
ax.plot([0, 0], [self.pickoff_ysize/2, self.pickoff_diam/2], "b")
ax.plot([0, 0], [-self.pickoff_ysize/2, -self.pickoff_diam/2], "b")
def plotgrid(self, x0, y0, ax, npts=15):
"""
Plot a grid of points representing Shack-Hartmann apertures corresponding to wavefront sensor positioned at
a focal plane position of x0, y0 mm. This position is written in the FITS header keywords GUIDERX and GUIDERY.
"""
ngood = 0
for x in np.arange(-1, 1, 2.0 / npts):
for y in np.arange(-1, 1, 2.0 / npts):
if (np.hypot(x, y) < 1 and | np.hypot(x, y) | numpy.hypot |
# -*- coding: utf-8 -*-
# Copyright (c) 2019 the HERA Project
# Licensed under the MIT License
import pytest
import os
import shutil
import hera_qm.xrfi as xrfi
import numpy as np
import pyuvdata.tests as uvtest
from pyuvdata import UVData
from pyuvdata import UVCal
import hera_qm.utils as utils
from hera_qm.data import DATA_PATH
from pyuvdata import UVFlag
import glob
test_d_file = os.path.join(DATA_PATH, 'zen.2457698.40355.xx.HH.uvcAA')
test_uvfits_file = os.path.join(DATA_PATH, 'zen.2457698.40355.xx.HH.uvcAA.uvfits')
test_uvh5_file = os.path.join(DATA_PATH, 'zen.2457698.40355.xx.HH.uvh5')
test_c_file = os.path.join(DATA_PATH, 'zen.2457698.40355.xx.HH.uvcAA.omni.calfits')
test_f_file = test_d_file + '.testuvflag.h5'
test_f_file_flags = test_d_file + '.testuvflag.flags.h5' # version in 'flag' mode
test_outfile = os.path.join(DATA_PATH, 'test_output', 'uvflag_testout.h5')
xrfi_path = os.path.join(DATA_PATH, 'test_output')
test_flag_integrations= os.path.join(DATA_PATH, 'a_priori_flags_integrations.yaml')
test_flag_jds= os.path.join(DATA_PATH, 'a_priori_flags_jds.yaml')
test_flag_lsts= os.path.join(DATA_PATH, 'a_priori_flags_lsts.yaml')
test_uvh5_files = ['zen.2457698.40355191.xx.HH.uvh5',
'zen.2457698.40367619.xx.HH.uvh5',
'zen.2457698.40380046.xx.HH.uvh5']
test_c_files = ['zen.2457698.40355191.xx.HH.uvcAA.omni.calfits',
'zen.2457698.40367619.xx.HH.uvcAA.omni.calfits',
'zen.2457698.40380046.xx.HH.uvcAA.omni.calfits']
for cnum, cf, uvf in zip(range(3), test_c_files, test_uvh5_files):
test_c_files[cnum] = os.path.join(DATA_PATH, cf)
test_uvh5_files[cnum] = os.path.join(DATA_PATH, uvf)
pytestmark = pytest.mark.filterwarnings(
"ignore:The uvw_array does not match the expected values given the antenna positions.",
"ignore:telescope_location is not set. Using known values for HERA.",
"ignore:antenna_positions is not set. Using known values for HERA."
)
def test_uvdata():
uv = UVData()
uv.read_miriad(test_d_file)
xant = uv.get_ants()[0]
xrfi.flag_xants(uv, xant)
assert np.all(uv.flag_array[uv.ant_1_array == xant, :, :, :])
assert np.all(uv.flag_array[uv.ant_2_array == xant, :, :, :])
def test_uvcal():
uvc = UVCal()
uvc.read_calfits(test_c_file)
xant = uvc.ant_array[0]
xrfi.flag_xants(uvc, xant)
assert np.all(uvc.flag_array[0, :, :, :, :])
def test_uvflag():
uvf = UVFlag(test_f_file)
uvf.to_flag()
xant = uvf.ant_1_array[0]
xrfi.flag_xants(uvf, xant)
assert np.all(uvf.flag_array[uvf.ant_1_array == xant, :, :, :])
assert np.all(uvf.flag_array[uvf.ant_2_array == xant, :, :, :])
def test_input_error():
pytest.raises(ValueError, xrfi.flag_xants, 4, 0)
def test_uvflag_waterfall_error():
uvf = UVFlag(test_f_file)
uvf.to_waterfall()
uvf.to_flag()
pytest.raises(ValueError, xrfi.flag_xants, uvf, 0)
def test_uvflag_not_flag_error():
uvf = UVFlag(test_f_file)
pytest.raises(ValueError, xrfi.flag_xants, uvf, 0)
def test_not_inplace_uvflag():
uvf = UVFlag(test_f_file)
xant = uvf.ant_1_array[0]
uvf2 = xrfi.flag_xants(uvf, xant, inplace=False)
assert np.all(uvf2.flag_array[uvf2.ant_1_array == xant, :, :, :])
assert np.all(uvf2.flag_array[uvf2.ant_2_array == xant, :, :, :])
def test_not_inplace_uvdata():
uv = UVData()
uv.read_miriad(test_d_file)
xant = uv.get_ants()[0]
uv2 = xrfi.flag_xants(uv, xant, inplace=False)
assert np.all(uv2.flag_array[uv2.ant_1_array == xant, :, :, :])
assert np.all(uv2.flag_array[uv2.ant_2_array == xant, :, :, :])
def test_resolve_xrfi_path_given():
dirname = xrfi.resolve_xrfi_path(xrfi_path, test_d_file)
assert xrfi_path == dirname
def test_resolve_xrfi_path_empty():
dirname = xrfi.resolve_xrfi_path('', test_d_file)
assert os.path.dirname(os.path.abspath(test_d_file)) == dirname
def test_resolve_xrfi_path_does_not_exist():
dirname = xrfi.resolve_xrfi_path(os.path.join(xrfi_path, 'foogoo'), test_d_file)
assert os.path.dirname(os.path.abspath(test_d_file)) == dirname
def test_resolve_xrfi_path_jd_subdir():
dirname = xrfi.resolve_xrfi_path('', test_d_file, jd_subdir=True)
expected_dir = os.path.join(os.path.dirname(os.path.abspath(test_d_file)),
'.'.join(os.path.basename(test_d_file).split('.')[0:3])
+ '.xrfi')
assert dirname == expected_dir
assert os.path.exists(expected_dir)
shutil.rmtree(expected_dir)
def test_check_convolve_dims_3D():
# Error if d.ndims != 2
pytest.raises(ValueError, xrfi._check_convolve_dims, np.ones((3, 2, 3)), 1, 2)
def test_check_convolve_dims_1D():
size = 10
d = np.ones(size)
with uvtest.check_warnings(
UserWarning,
match=f"K1 value {size + 1} is larger than the data",
nwarnings=1
):
K = xrfi._check_convolve_dims(d, size + 1)
assert K == size
def test_check_convolve_dims_kernel_not_given():
size = 10
d = np.ones((size, size))
with uvtest.check_warnings(
UserWarning,
match=["No K1 input provided.", "No K2 input provided"],
nwarnings=2
):
K1, K2 = xrfi._check_convolve_dims(d)
assert K1 == size
assert K2 == size
def test_check_convolve_dims_Kt_too_big():
size = 10
d = np.ones((size, size))
with uvtest.check_warnings(
UserWarning,
match=f"K1 value {size + 1} is larger than the data",
nwarnings=1,
):
Kt, Kf = xrfi._check_convolve_dims(d, size + 1, size)
assert Kt == size
assert Kf == size
def test_check_convolve_dims_Kf_too_big():
size = 10
d = np.ones((size, size))
with uvtest.check_warnings(
UserWarning,
match=f"K2 value {size + 1} is larger than the data",
nwarnings=1,
):
Kt, Kf = xrfi._check_convolve_dims(d, size, size + 1)
assert Kt == size
assert Kf == size
def test_check_convolve_dims_K1K2_lt_one():
size = 10
data = np.ones((size, size))
pytest.raises(ValueError, xrfi._check_convolve_dims, data, 0, 2)
pytest.raises(ValueError, xrfi._check_convolve_dims, data, 2, 0)
def test_robus_divide():
a = np.array([1., 1., 1.], dtype=np.float32)
b = np.array([2., 0., 1e-9], dtype=np.float32)
c = xrfi.robust_divide(a, b)
assert np.array_equal(c, np.array([1. / 2., np.inf, np.inf]))
@pytest.fixture(scope='function')
def fake_data():
size = 100
fake_data = np.zeros((size, size))
# yield returns the data and lets us do post test clean up after
yield fake_data
# post-test clean up
del(fake_data)
return
def test_medmin(fake_data):
# make fake data
for i in range(fake_data.shape[1]):
fake_data[:, i] = i * np.ones_like(fake_data[:, i])
# medmin should be .size - 1 for these data
medmin = xrfi.medmin(fake_data)
assert np.allclose(medmin, fake_data.shape[0] - 1)
# Test error when wrong dimensions are passed
pytest.raises(ValueError, xrfi.medmin, np.ones((5, 4, 3)))
def test_medminfilt(fake_data):
# make fake data
for i in range(fake_data.shape[1]):
fake_data[:, i] = i * np.ones_like(fake_data[:, i])
# run medmin filt
Kt = 8
Kf = 8
d_filt = xrfi.medminfilt(fake_data, Kt=Kt, Kf=Kf)
# build up "answer" array
ans = np.zeros_like(fake_data)
for i in range(fake_data.shape[1]):
if i < fake_data.shape[0] - Kf:
ans[:, i] = i + (Kf - 1)
else:
ans[:, i] = fake_data.shape[0] - 1
assert np.allclose(d_filt, ans)
def test_detrend_deriv(fake_data):
# make fake data
for i in range(fake_data.shape[0]):
for j in range(fake_data.shape[1]):
fake_data[i, j] = j * i**2 + j**3
# run detrend_deriv in both dimensions
dtdf = xrfi.detrend_deriv(fake_data, df=True, dt=True)
ans = np.ones_like(dtdf)
assert np.allclose(dtdf, ans)
# only run along frequency
for i in range(fake_data.shape[0]):
for j in range(fake_data.shape[1]):
fake_data[i, j] = j**3
df = xrfi.detrend_deriv(fake_data, df=True, dt=False)
ans = np.ones_like(df)
assert np.allclose(df, ans)
# only run along time
for i in range(fake_data.shape[0]):
for j in range(fake_data.shape[1]):
fake_data[i, j] = i**3
dt = xrfi.detrend_deriv(fake_data, df=False, dt=True)
ans = np.ones_like(dt)
assert np.allclose(dt, ans)
# catch error of df and dt both being False
pytest.raises(ValueError, xrfi.detrend_deriv, fake_data, dt=False, df=False)
# Test error when wrong dimensions are passed
pytest.raises(ValueError, xrfi.detrend_deriv, np.ones((5, 4, 3)))
def test_detrend_medminfilt(fake_data):
# make fake data
for i in range(fake_data.shape[1]):
fake_data[:, i] = i * np.ones_like(fake_data[:, i])
# run detrend_medminfilt
Kt = 8
Kf = 8
dm = xrfi.detrend_medminfilt(fake_data, Kt=Kt, Kf=Kf)
# read in "answer" array
# this is output that corresponds to .size==100, Kt==8, Kf==8
ans_fn = os.path.join(DATA_PATH, 'test_detrend_medminfilt_ans.txt')
ans = np.loadtxt(ans_fn)
assert np.allclose(ans, dm)
def test_detrend_medfilt():
# make fake data
x = np.sin(np.linspace(0, 2.1 * np.pi, 100))
y = np.cos(np.linspace(0, 5.3 * np.pi, 100))
fake_data = np.outer(x,y)
# run detrend medfilt
Kt = 101
Kf = 101
with uvtest.check_warnings(
UserWarning,
match=[
f"K1 value {Kt} is larger than the data",
f"K2 value {Kf} is larger than the data",
],
nwarnings=2,
):
dm = xrfi.detrend_medfilt(fake_data, None, Kt, Kf)
# read in "answer" array
# this is output that corresponds to .size==100, Kt==101, Kf==101
ans_fn = os.path.join(DATA_PATH, 'test_detrend_medfilt_ans_v2.txt')
ans = np.loadtxt(ans_fn)
np.testing.assert_array_almost_equal(ans, dm)
def test_detrend_medfilt_complex():
# use complex data
x = np.sin(np.linspace(0, 2.1 * np.pi, 100)) + 1.0j * np.cos(np.linspace(0, 1.3 * np.pi, 100))
y = np.cos(np.linspace(0, 5.3 * np.pi, 100)) + 1.0j * np.sin(np.linspace(0, 2.9 * np.pi, 100))
fake_data = np.outer(x,y)
# run detrend_medfilt
Kt = 8
Kf = 8
dm = xrfi.detrend_medfilt(fake_data, Kt=Kt, Kf=Kf)
# read in "answer" array
# this is output that corresponds to .size=100, Kt=8, Kf=8
ans_fn = os.path.join(DATA_PATH, 'test_detrend_medfilt_complex_ans_v2.txt')
ans = np.loadtxt(ans_fn).view('complex')
np.testing.assert_array_almost_equal(ans, dm)
def test_detrend_medfilt_3d_error():
# Test error when wrong dimensions are passed
pytest.raises(ValueError, xrfi.detrend_medfilt, np.ones((5, 4, 3)))
def test_detrend_meanfilt(fake_data):
# make fake data
for i in range(fake_data.shape[1]):
fake_data[:, i] = i**2 * np.ones_like(fake_data[:, i])
# run detrend medfilt
Kt = 8
Kf = 8
dm = xrfi.detrend_meanfilt(fake_data, Kt=Kt, Kf=Kf)
# read in "answer" array
# this is output that corresponds to .size==100, Kt==8, Kf==8
ans_fn = os.path.join(DATA_PATH, 'test_detrend_meanfilt_ans.txt')
ans = np.loadtxt(ans_fn)
assert np.allclose(ans, dm)
def test_detrend_meanfilt_flags(fake_data):
# make fake data
for i in range(fake_data.shape[1]):
fake_data[:, i] = i * np.ones_like(fake_data[:, i])
ind = int(fake_data.shape[0] / 2)
fake_data[ind, :] = 10000.
flags = np.zeros(fake_data.shape, dtype=np.bool_)
flags[ind, :] = True
# run detrend medfilt
Kt = 8
Kf = 8
dm1 = xrfi.detrend_meanfilt(fake_data, flags=flags, Kt=Kt, Kf=Kf)
# Compare with drastically different flagged values
fake_data[ind, :] = 0
dm2 = xrfi.detrend_meanfilt(fake_data, flags=flags, Kt=Kt, Kf=Kf)
dm2[ind, :] = dm1[ind, :] # These don't have valid values, so don't compare them.
assert np.allclose(dm1, dm2)
def test_zscore_full_array(fake_data):
# Make some fake data
np.random.seed(182)
fake_data[...] = np.random.randn(fake_data.shape[0], fake_data.shape[1])
out = xrfi.zscore_full_array(fake_data)
fake_mean = np.mean(fake_data)
fake_std = np.std(fake_data)
assert np.all(out == (fake_data - fake_mean) / fake_std)
def test_zscore_full_array_flags(fake_data):
# Make some fake data
np.random.seed(182)
fake_data[...] = np.random.randn(fake_data.shape[0], fake_data.shape[1])
flags = np.zeros(fake_data.shape, dtype=np.bool_)
flags[45, 33] = True
out = xrfi.zscore_full_array(fake_data, flags=flags)
fake_mean = np.mean(np.ma.masked_array(fake_data, flags))
fake_std = np.std(np.ma.masked_array(fake_data, flags))
out_exp = (fake_data - fake_mean) / fake_std
out_exp[45, 33] = np.inf
assert np.all(out == out_exp)
def test_zscore_full_array_modified(fake_data):
# Make some fake data
np.random.seed(182)
fake_data[...] = np.random.randn(fake_data.shape[0], fake_data.shape[1])
out = xrfi.zscore_full_array(fake_data, modified=True)
fake_med = np.median(fake_data)
fake_mad = np.median(np.abs(fake_data - fake_med))
assert np.all(out == (fake_data - fake_med) / (1.486 * fake_mad))
def test_zscore_full_array_modified_complex(fake_data):
# Make some fake data
np.random.seed(182)
rands = np.random.randn(100, 100)
fake_data = rands + 1j * rands
out = xrfi.zscore_full_array(fake_data, modified=True)
fake_med = np.median(rands)
fake_mad = np.sqrt(2) * np.median(np.abs(rands - fake_med))
assert np.allclose(out, (fake_data - fake_med - 1j * fake_med) / (1.486 * fake_mad))
def test_modzscore_1d_no_detrend():
npix = 1000
np.random.seed(182)
data = np.random.randn(npix)
data[50] = 500
out = xrfi.modzscore_1d(data, detrend=False)
assert out.shape == (npix,)
assert np.isclose(out[50], 500, rtol=.2)
assert np.isclose(np.median(np.abs(out)), .67, rtol=.1)
def test_modzscore_1d():
npix = 1000
np.random.seed(182)
data = np.random.randn(npix)
data[50] = 500
data += .1 * np.arange(npix)
out = xrfi.modzscore_1d(data)
assert out.shape == (npix,)
assert np.isclose(out[50], 500, rtol=.2)
assert np.isclose(np.median(np.abs(out)), .67, rtol=.1)
def test_watershed_flag():
# generate a metrics and flag UVFlag object
uv = UVData()
uv.read_miriad(test_d_file)
uvm = UVFlag(uv, history='I made this')
uvf = UVFlag(uv, mode='flag')
# set metric and flag arrays to specific values
uvm.metric_array = np.zeros_like(uvm.metric_array)
uvf.flag_array = np.zeros_like(uvf.flag_array, dtype=np.bool_)
uvm.metric_array[0, 0, 1, 0] = 7.
uvf.flag_array[0, 0, 0, 0] = True
# run watershed flag
xrfi.watershed_flag(uvm, uvf, nsig_p=2., inplace=True)
# check answer
flag_array = np.zeros_like(uvf.flag_array, dtype=np.bool_)
flag_array[0, 0, :2, 0] = True
assert np.allclose(uvf.flag_array, flag_array)
# test flagging channels adjacent to fully flagged ones
uvm.metric_array = np.zeros_like(uvm.metric_array)
uvf.flag_array = np.zeros_like(uvf.flag_array, dtype=np.bool_)
uvm.metric_array[:, :, 1, :] = 1.
uvf.flag_array[:, :, 0, :] = True
# run watershed flag
xrfi.watershed_flag(uvm, uvf, nsig_p=2., nsig_f=0.5, inplace=True)
# check answer
flag_array = np.zeros_like(uvf.flag_array, dtype=np.bool_)
flag_array[:, :, :2, :] = True
assert np.allclose(uvf.flag_array, flag_array)
# test flagging times adjacent to fully flagged ones
uvm.metric_array = np.zeros_like(uvm.metric_array)
uvf.flag_array = np.zeros_like(uvf.flag_array, dtype=np.bool_)
times = np.unique(uv.time_array)
inds1 = np.where(uv.time_array == times[0])[0]
inds2 = np.where(uv.time_array == times[1])[0]
uvm.metric_array[inds2, 0, :, 0] = 1.
uvf.flag_array[inds1, 0, :, 0] = True
# run watershed flag
xrfi.watershed_flag(uvm, uvf, nsig_p=2., nsig_t=0.5, inplace=True)
# check answer
flag_array = np.zeros_like(uvf.flag_array, dtype=np.bool_)
flag_array[inds1, 0, :, 0] = True
flag_array[inds2, 0, :, 0] = True
assert np.allclose(uvf.flag_array, flag_array)
# test antenna type objects
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvm = UVFlag(uvc, history='I made this')
uvf = UVFlag(uvc, mode='flag')
# set metric and flag arrays to specific values
uvm.metric_array = | np.zeros_like(uvm.metric_array) | numpy.zeros_like |
"""Unit test for the contents of regression_analysis.utils.findStat."""
import numpy as np
import sklearn.metrics as sm
from regression_analysis.fit_model import linear_regression
from regression_analysis.utils import franke, findStat
def get_model_output():
# Get data from Franke function
x1, x2, y = franke.create_data(num_points=100, noise_variance=0)
# Get design matrix
X = linear_regression.design_mat2D(np.squeeze(x1), np.squeeze(x2), 5)
# Get betas from scikit
beta_OLS = linear_regression.find_model_parameter(X, y, "scikit_ols", 0)
beta_RR = linear_regression.find_model_parameter(X, y, "scikit_ridge", 1)
beta_LR = linear_regression.find_model_parameter(X, y, "scikit_lasso", 1)
# Get y
y_OLS = X @ beta_OLS
y_RR = X @ beta_RR
y_LR = X @ beta_LR
return y, y_OLS, y_RR, y_LR
def test_findMSE():
"""Test if the MSE from our code is the same as the one from scikit-learn."""
y, y_OLS, y_RR, y_LR = get_model_output()
# Calculate mean squared error
MSE_OLS_own = findStat.findMSE(y, y_OLS)
MSE_RR_own = findStat.findMSE(y, y_RR)
MSE_LR_own = findStat.findMSE(y, y_LR)
MSE_OLS_scikit = sm.mean_squared_error(y, y_OLS)
MSE_RR_scikit = sm.mean_squared_error(y, y_RR)
MSE_LR_scikit = sm.mean_squared_error(y, y_LR)
np.testing.assert_array_equal(MSE_OLS_own, MSE_OLS_scikit)
| np.testing.assert_array_equal(MSE_RR_own, MSE_RR_scikit) | numpy.testing.assert_array_equal |
import cv2
import numpy as np
from scipy.ndimage.measurements import label
from code.features import FeatureExtractor
from collections import deque
HEAT_INCREMENT = 10
class VehicleDetector:
def __init__(self, svc, scaler, n_rows, n_cols, config, buffer_size = 8):
self.svc = svc
self.scaler = scaler
self.n_rows = n_rows
self.n_cols = n_cols
#self.orientations = config["orientations"]
self.pix_per_cell = config["pix_per_cell"]
self.cell_per_block = config["cell_per_block"]
self.spatial_size = config["spatial_size"]
self.histogram_bins = config["histogram_bins"]
self.window = config["window"]
n_rows_min = int(n_rows / 1.8)
n_cols_min = 100
self.search_parameters = [(n_rows_min, (n_rows_min + 200), n_cols // 2, n_cols, 1.5, 2),
(n_rows_min, (n_rows_min + 250), n_cols_min, n_cols, 2, 1)]
self.config = config
self.heatmap_buffer = deque(maxlen = buffer_size)
self.feature_extractor = FeatureExtractor(config)
def _image_region_search(self, image_region, v_min, h_min, scale, cells_per_step, cpu_pool = None):
if scale != 1.0:
if scale > 1.0:
interpolation = cv2.INTER_AREA
else:
interpolation = cv2.INTER_LINEAR
image_region = cv2.resize(image_region, (np.int(image_region.shape[1] / scale), np.int(image_region.shape[0] / scale)), interpolation = interpolation)
n_hblocks = (image_region.shape[1] // self.pix_per_cell) - self.cell_per_block + 1
n_vblocks = (image_region.shape[0] // self.pix_per_cell) - self.cell_per_block + 1
n_blocks_per_window = (self.window // self.pix_per_cell) - self.cell_per_block + 1
h_steps = (n_hblocks - n_blocks_per_window) // cells_per_step + 1
v_steps = (n_vblocks - n_blocks_per_window) // cells_per_step + 1
windows = []
predictions = []
for h_step in range(h_steps):
for v_step in range(v_steps):
h_pos = h_step * cells_per_step
v_pos = v_step * cells_per_step
window_min_h = h_pos * self.pix_per_cell
window_min_v = v_pos * self.pix_per_cell
image_window = image_region[window_min_v:window_min_v + self.window , window_min_h:window_min_h + self.window]
if (image_window.shape[0] < self.window) or (image_window.shape[1] < self.window):
image_window = cv2.resize(image_window, (self.window , self.window ), interpolation = cv.INTER_LINEAR)
features = self.feature_extractor.extract_image_features(image_window, cpu_pool = cpu_pool)
features = self.scaler.transform(features.reshape(1, -1))
prediction = self.svc.predict(features)[0]
window_scale = np.int(self.window * scale)
top_left = (np.int(window_min_h * scale) + h_min, np.int(window_min_v * scale) + v_min)
bottom_right = (top_left[0] + window_scale, top_left[1] + window_scale)
windows.append((top_left, bottom_right))
predictions.append(prediction)
return windows, predictions
def _image_search(self, image, search_parameters, cpu_pool = None):
windows = []
predictions = []
for v_min, v_max, h_min, h_max, scale, cells_per_step in search_parameters:
image_region = image[v_min:v_max, h_min:h_max, :]
_windows, _predictions = self._image_region_search(image_region, v_min, h_min, scale, cells_per_step, cpu_pool = cpu_pool)
windows.append(_windows)
predictions.append(_predictions)
# Flatten lists
windows = [item for sublist in windows for item in sublist]
predictions = [item for sublist in predictions for item in sublist]
return windows, predictions
def _make_heatmap(self, windows, predictions):
heatmap = np.zeros((self.n_rows, self.n_cols), dtype = np.float)
n_samples = len(windows)
for i in range(n_samples):
if predictions[i] == 1:
window = windows[i]
heatmap[window[0][1]:window[1][1], window[0][0]:window[1][0]] += HEAT_INCREMENT
return heatmap
def _bounding_boxes(self, heatmap, min_width, min_height):
labels = label(heatmap)
bounding_boxes = []
for car_n in range(1, labels[1] + 1):
tmp = (labels[0] == car_n).nonzero()
nonzero_x = np.array(tmp[1])
nonzero_y = | np.array(tmp[0]) | numpy.array |
import numpy as np
def QRDecomposition(A):
n = np.shape(A)[0] #pegando o tamanho das linhas de A
m = np.shape(A)[1] #pegando o tamanho das colunas de A
Q = np.zeros((n,m)) #declarando a matriz Q
R = np.zeros((m,m)) #declarando a matriz R
for j in range(0, m):
A_column = A[:, j] #pegando as colunas da matriz A
V = np.zeros(n) #declarando o vetor V
V = A_column #V igual a coluna j de A
for i in range (0, j):
R[i,j] = Q[:,i].dot(A_column) #fazendo o calculo do R[i,j] = coluna i de Q * coluna j de A ( i != j)
V -= (Q[:,i].dot(A_column))*Q[:,i] #fazendo o calculo de V
R[j,j] = np.linalg.norm(V) # R[j,j] = norma da coluna j de A (i == j)
Q[:,j] = V/np.linalg.norm(V) #normalizando V e atribuindo a coluna j de Q
return Q, R
def decompLU(A):
L = np.eye(np.shape(A)[0]) #matriz L com a dimensao de A com a diagonal principla igual a 1
U = np.zeros( | np.shape(A) | numpy.shape |
#!/usr/bin/env python
#_*_coding:utf-8_*_
import numpy as np
import math
def Calculate_Fscore(array, labels):
if len(array) != len(labels):
print('Error. inconsistent data shape with sample number')
return 0
array_po = []
array_ne = []
for i in range(len(labels)):
if labels[i] == 1:
array_po.append(array[i])
else:
array_ne.append(array[i])
mean_po = sum(array_po) / len(array_po)
mean_ne = sum(array_ne) / len(array_ne)
mean = sum(array) / len(array)
score_1 = ((mean_po - mean) ** 2 + (mean_ne - mean) ** 2)
score_2 = sum([(i-mean_po) ** 2 for i in array_po]) / (len(array_po) - 1)
score_3 = sum([(i-mean_ne) ** 2 for i in array_ne]) / (len(array_ne) - 1)
f_score = score_1 / (score_2 + score_3)
return f_score
def Fscore(encodings, labels):
features = encodings[0][1:]
encodings = | np.array(encodings) | numpy.array |
#!/usr/bin/env python3
import os
import sys
import glob
import argparse
import logging
import numpy as np
from astropy.coordinates import SkyCoord
from astropy.coordinates.name_resolve import NameResolveError
from astropy.time import Time
import astropy.constants as const
import astropy.units as u
import tqdm
from arts_tracking_beams import ARTSFITSReader, TrackingBeam
from arts_tracking_beams.tools import radec_to_hadec
from arts_tracking_beams.constants import NTAB, CB_HPBW, REF_FREQ, BMAX
def get_input_path(input_folder, taskid=None, cb=None):
"""
Get input file path
:param str input_folder: Folder containing FITS files
:param str taskid: observation taskid (required if more than one observation is present)
:param int cb: observation compound beam (required if more than one CB is present)
:return: file path formatted as <path>/ARTS<taskid>_CB<cb>_{tab:02d}.fits
"""
# construct glob pattern
pattern = f'{input_folder}/ARTS'
if taskid is not None:
pattern += f'{taskid}'
if cb is not None:
pattern += f'*CB{cb:02d}'
pattern += '*.fits'
# get list of files
files = glob.glob(pattern)
if not files:
logging.error("No input files found")
sys.exit(1)
# there should be one file per TAB
if not len(files) == NTAB:
logging.error(f'Expected {NTAB} files but found {len(files)}')
sys.exit(1)
# construct the file path with formatter for TAB index
# first sort so TAB00 file is first
pth = sorted(files)[0].replace('TAB00', 'TAB{tab:02d}')
logging.debug(f'Input FITS path: {pth}')
return pth
def get_source_coordinates(name=None, ra=None, dec=None):
"""
Get source coordinates
:param str name: source name (to resolve with SkyCoord.from_name)
:param str ra: Right Ascension (hh:mm:ss.s, ignored if name is given)
:param str dec: Declination (dd:mm:ss.s, ignored if name is given)
:return: source coordinates (SkyCoord)
"""
if name is not None:
try:
coord = SkyCoord.from_name(name)
except NameResolveError:
logging.error(f'Could not find coordinates for source {name}')
sys.exit(1)
else:
if ra is None or dec is None:
logging.error('RA and Dec must be specified if source name is not specified')
sys.exit(1)
coord = SkyCoord(ra, dec, unit=(u.hourangle, u.deg))
logging.debug(f'Source coordinates: {coord.to_string("hmsdms", precision=1)}')
return coord
def required_tb_resolution(pointing, tstart, duration, fhi):
"""
Calculate the required time interval for calculating the TB TAB indices.
This is set by the time required to cross a single TAB at 15"/second Earth rotation,
at the point in the observation where the TABs are narrowest (i.e. HA closest to zero)
Worst case is roughly 1.1 second, which nicely fits the typical FITS subint length of 1.024s
:param SkyCoord pointing: CB pointing
:param Time tstart: Observation start time
:param Quantity duration: Observation duration
:param Quantity fhi: Highest frequency of observation
:return: TB time resolution (Quantity)
"""
# get HA, Dec at start and end of observation
ha_s, dec_s = radec_to_hadec(pointing.ra, pointing.dec, tstart)
ha_e, dec_e = radec_to_hadec(pointing.ra, pointing.dec, tstart + duration)
# if one HA is negative and the other positive, the minimum HA is zero
if (ha_s * ha_e).value < 0:
ha = 0 * u.deg
else:
# find value closest to zero, sign does not matter as projection effect is symmetric around HA=0
ha = min(np.abs(ha_s), | np.abs(ha_e) | numpy.abs |
# plotting
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
import seaborn as sns
# numpy
import numpy as np
# scipy
import scipy as sp
import scipy.interpolate
from scipy.special import erfinv, erf
from scipy.stats import poisson as pss
import scipy.fftpack
import scipy.sparse
# jit
from numba import jit
import ctypes
import astropy
import astropy as ap
from astropy.convolution import convolve_fft, AiryDisk2DKernel
import pickle
# multiprocessing
import multiprocessing as mp
from copy import deepcopy
# utilities
import os, time, sys, glob, fnmatch, inspect, traceback, functools
# HealPix
import healpy as hp
# ignore warnings if not in diagnostic mode
import warnings
#seterr(divide='raise', over='raise', invalid='raise')
#seterr(all='raise')
#seterr(under='ignore')
#warnings.simplefilter('ignore')
#np.set_printoptions(linewidth=180)
#sns.set(context='poster', style='ticks', color_codes=True)
import h5py
# utilities
# secondaries
## Symbolic Jacobian calculation
#import sympy
# tdpy
import tdpy
from tdpy.util import summgene
# photometry related
### find the spectra of sources
def retr_spec(gdat, flux, sind=None, curv=None, expc=None, sindcolr=None, elin=None, edisintp=None, sigm=None, gamm=None, spectype='powr', plot=False):
if gdat.numbener == 1:
spec = flux[None, :]
else:
if plot:
meanener = gdat.meanpara.enerplot
else:
meanener = gdat.meanpara.ener
if gmod.spectype == 'gaus':
spec = 1. / edis[None, :] / np.sqrt(2. * pi) * flux[None, :] * np.exp(-0.5 * ((gdat.meanpara.ener[:, None] - elin[None, :]) / edis[None, :])**2)
if gmod.spectype == 'voig':
args = (gdat.meanpara.ener[:, None] + 1j * gamm[None, :]) / np.sqrt(2.) / sigm[None, :]
spec = 1. / sigm[None, :] / np.sqrt(2. * pi) * flux[None, :] * real(scipy.special.wofz(args))
if gmod.spectype == 'edis':
edis = edisintp(elin)[None, :]
spec = 1. / edis / np.sqrt(2. * pi) * flux[None, :] * np.exp(-0.5 * ((gdat.meanpara.ener[:, None] - elin[None, :]) / edis)**2)
if gmod.spectype == 'pvoi':
spec = 1. / edis / np.sqrt(2. * pi) * flux[None, :] * np.exp(-0.5 * ((gdat.meanpara.ener[:, None] - elin[None, :]) / edis)**2)
if gmod.spectype == 'lore':
spec = 1. / edis / np.sqrt(2. * pi) * flux[None, :] * np.exp(-0.5 * ((gdat.meanpara.ener[:, None] - elin[None, :]) / edis)**2)
if gmod.spectype == 'powr':
spec = flux[None, :] * (meanener / gdat.enerpivt)[:, None]**(-sind[None, :])
if gmod.spectype == 'colr':
if plot:
spec = np.zeros((gdat.numbenerplot, flux.size))
else:
spec = np.empty((gdat.numbener, flux.size))
for i in gdat.indxener:
if i < gdat.indxenerpivt:
spec[i, :] = flux * (gdat.meanpara.ener[i] / gdat.enerpivt)**(-sindcolr[i])
elif i == gdat.indxenerpivt:
spec[i, :] = flux
else:
spec[i, :] = flux * (gdat.meanpara.ener[i] / gdat.enerpivt)**(-sindcolr[i-1])
if gmod.spectype == 'curv':
spec = flux[None, :] * meanener[:, None]**(-sind[None, :] - gdat.factlogtenerpivt[:, None] * curv[None, :])
if gmod.spectype == 'expc':
spec = flux[None, :] * (meanener / gdat.enerpivt)[:, None]**(-sind[None, :]) * np.exp(-(meanener - gdat.enerpivt)[:, None] / expc[None, :])
return spec
### find the surface brightness due to one point source
def retr_sbrtpnts(gdat, lgal, bgal, spec, psfnintp, indxpixlelem):
# calculate the distance to all pixels from each point source
dist = retr_angldistunit(gdat, lgal, bgal, indxpixlelem)
# interpolate the PSF onto the pixels
if gdat.kernevaltype == 'ulip':
psfntemp = psfnintp(dist)
if gdat.kernevaltype == 'bspx':
pass
# scale by the PS spectrum
sbrtpnts = spec[:, None, None] * psfntemp
return sbrtpnts
def retr_psfnwdth(gdat, psfn, frac):
'''
Return the PSF width
'''
wdth = np.zeros((gdat.numbener, gdat.numbevtt))
for i in gdat.indxener:
for m in gdat.indxevtt:
psfntemp = psfn[i, :, m]
indxanglgood = np.argsort(psfntemp)
intpwdth = max(frac * np.amax(psfntemp), np.amin(psfntemp))
if intpwdth >= np.amin(psfntemp[indxanglgood]) and intpwdth <= np.amax(psfntemp[indxanglgood]):
wdthtemp = sp.interpolate.interp1d(psfntemp[indxanglgood], gdat.binspara.angl[indxanglgood], fill_value='extrapolate')(intpwdth)
else:
wdthtemp = 0.
wdth[i, m] = wdthtemp
return wdth
# lensing-related
def samp_lgalbgalfromtmpl(gdat, probtmpl):
indxpixldraw = np.random.choice(gdat.indxpixl, p=probtmpl)
lgal = gdat.lgalgrid[indxpixldraw] + randn(gdat.sizepixl)
bgal = gdat.bgalgrid[indxpixldraw] + randn(gdat.sizepixl)
return lgal, bgal
## custom random variables, pdfs, cdfs and icdfs
### probability distribution functions
def retr_lprbpois(data, modl):
lprb = data * np.log(modl) - modl - sp.special.gammaln(data + 1)
return lprb
### probability density functions
def pdfn_self(xdat, minm, maxm):
pdfn = 1. / (maxm - minm)
return pdfn
def pdfn_expo(xdat, maxm, scal):
if (xdat > maxm).any():
pdfn = 0.
else:
pdfn = 1. / scal / (1. - np.exp(-maxm / scal)) * np.exp(-xdat / scal)
return pdfn
def pdfn_dexp(xdat, maxm, scal):
pdfn = 0.5 * pdfn_expo(np.fabs(xdat), maxm, scal)
return pdfn
def pdfn_dpow(xdat, minm, maxm, brek, sloplowr, slopuppr):
if np.isscalar(xdat):
xdat = np.array([xdat])
faca = 1. / (brek**(sloplowr - slopuppr) * (brek**(1. - sloplowr) - minm**(1. - sloplowr)) / \
(1. - sloplowr) + (maxm**(1. - slopuppr) - brek**(1. - slopuppr)) / (1. - slopuppr))
facb = faca * brek**(sloplowr - slopuppr) / (1. - sloplowr)
pdfn = np.empty_like(xdat)
indxlowr = np.where(xdat <= brek)[0]
indxuppr = np.where(xdat > brek)[0]
if indxlowr.size > 0:
pdfn[indxlowr] = faca * brek**(sloplowr - slopuppr) * xdat[indxlowr]**(-sloplowr)
if indxuppr.size > 0:
pdfn[indxuppr] = faca * xdat[indxuppr]**(-slopuppr)
return pdfn
def pdfn_powr(xdat, minm, maxm, slop):
norm = (1. - slop) / (maxm**(1. - slop) - minm**(1. - slop))
pdfn = norm * xdat**(-slop)
return pdfn
def pdfn_logt(xdat, minm, maxm):
pdfn = 1. / (np.log(maxm) - np.log(minm)) / xdat
return pdfn
def pdfn_igam(xdat, slop, cutf):
pdfn = sp.stats.invgamma.pdf(xdat, slop - 1., scale=cutf)
return pdfn
def pdfn_lnor(xdat, mean, stdv):
pdfn = pdfn_gaus(np.log(xdat), np.log(mean), stdv)
return pdfn
def pdfn_gaus(xdat, mean, stdv):
pdfn = 1. / np.sqrt(2. * pi) / stdv * np.exp(-0.5 * ((xdat - mean) / stdv)**2)
return pdfn
def pdfn_lgau(xdat, mean, stdv):
pdfn = pdfn_gaus(np.log(xdat), np.log(mean), stdv)
return pdfn
def pdfn_atan(para, minmpara, maxmpara):
pdfn = 1. / (para**2 + 1.) / (np.arctan(maxmpara) - np.arctan(minmpara))
return pdfn
def cdfn_paragenrscalbase(gdat, strgmodl, paragenrscalbase, thisindxparagenrbase):
gmod = getattr(gdat, strgmodl)
scalparagenrbase = gmod.scalpara.genrbase[thisindxparagenrbase]
if scalparagenrbase == 'self' or scalparagenrbase == 'logt' or scalparagenrbase == 'atan':
listminmparagenrscalbase = gmod.minmpara.genrbase[thisindxparagenrbase]
factparagenrscalbase = gmod.factparagenrscalbase[thisindxparagenrbase]
if scalparagenrbase == 'self':
paragenrscalbaseunit = cdfn_self(paragenrscalbase, listminmparagenrscalbase, factparagenrscalbase)
elif scalparagenrbase == 'logt':
paragenrscalbaseunit = cdfn_logt(paragenrscalbase, listminmparagenrscalbase, factparagenrscalbase)
elif scalparagenrbase == 'atan':
gmod.listmaxmparagenrscalbase = gmod.listmaxmparagenrscalbase[thisindxparagenrbase]
paragenrscalbaseunit = cdfn_atan(paragenrscalbase, listminmparagenrscalbase, gmod.listmaxmparagenrscalbase)
elif scalparagenrbase == 'gaus' or scalparagenrbase == 'eerr':
gmod.listmeanparagenrscalbase = gmod.listmeanparagenrscalbase[thisindxparagenrbase]
gmod.liststdvparagenrscalbase = gmod.liststdvparagenrscalbase[thisindxparagenrbase]
if scalparagenrbase == 'eerr':
gmod.cdfnlistminmparagenrscalbaseunit = gmod.cdfnlistminmparagenrscalbaseunit[thisindxparagenrbase]
gmod.listparagenrscalbaseunitdiff = gmod.listparagenrscalbaseunitdiff[thisindxparagenrbase]
paragenrscalbaseunit = cdfn_eerr(paragenrscalbase, gmod.listmeanparagenrscalbase, gmod.liststdvparagenrscalbase, \
gmod.cdfnlistminmparagenrscalbaseunit, gmod.listparagenrscalbaseunitdiff)
else:
paragenrscalbaseunit = cdfn_gaus(paragenrscalbase, gmod.listmeanparagenrscalbase, gmod.liststdvparagenrscalbase)
elif scalparagenrbase == 'pois':
paragenrscalbaseunit = paragenrscalbase
if gdat.booldiagmode:
if paragenrscalbaseunit == 0:
print('Warning. CDF is zero.')
return paragenrscalbaseunit
def icdf_paragenrscalfull(gdat, strgmodl, paragenrunitfull, indxparagenrfullelem):
gmod = getattr(gdat, strgmodl)
# tobechanged
# temp -- change zeros to empty
paragenrscalfull = np.zeros_like(paragenrunitfull)
for scaltype in gdat.listscaltype:
listindxparagenrbasescal = gmod.listindxparagenrbasescal[scaltype]
if len(listindxparagenrbasescal) == 0:
continue
paragenrscalfull[listindxparagenrbasescal] = icdf_paragenrscalbase(gdat, strgmodl, paragenrunitfull[listindxparagenrbasescal], scaltype, listindxparagenrbasescal)
if not np.isfinite(paragenrscalfull).all():
raise Exception('')
if indxparagenrfullelem is not None:
for l in gmod.indxpopl:
for g in gmod.indxparagenrelemsing[l]:
indxparagenrfulltemp = indxparagenrfullelem[l][gmod.namepara.genrelem[l][g]]
if indxparagenrfulltemp.size == 0:
continue
paragenrscalfull[indxparagenrfulltemp] = icdf_trap(gdat, strgmodl, paragenrunitfull[indxparagenrfulltemp], paragenrscalfull, \
gmod.listscalparagenrelem[l][g], gmod.namepara.genrelem[l][g], l)
if gdat.booldiagmode:
if not np.isfinite(paragenrscalfull[indxparagenrfulltemp]).all():
raise Exception('')
if not np.isfinite(paragenrscalfull).all():
raise Exception('')
return paragenrscalfull
def icdf_paragenrscalbase(gdat, strgmodl, paragenrunitbase, scaltype, indxparagenrbasescal):
gmod = getattr(gdat, strgmodl)
if scaltype == 'self' or scaltype == 'logt' or scaltype == 'atan':
minmparagenrscalbase = gmod.minmpara.genrbase[indxparagenrbasescal]
factparagenrscalbase = gmod.factpara.genrbase[indxparagenrbasescal]
if scaltype == 'self':
paragenrscalbase = tdpy.icdf_self(paragenrunitbase, minmparagenrscalbase, factparagenrscalbase)
elif scaltype == 'logt':
paragenrscalbase = tdpy.icdf_logt(paragenrunitbase, minmparagenrscalbase, factparagenrscalbase)
elif scaltype == 'atan':
listmaxmparagenrscalbase = gmod.listmaxmparagenrscalbase[indxparagenrbasescal]
paragenrscalbase = tdpy.icdf_atan(paragenrunitbase, minmparagenrscalbase, listmaxmparagenrscalbase)
elif scaltype == 'gaus' or scaltype == 'eerr':
listmeanparagenrscalbase = gmod.listmeanparagenrscalbase[indxparagenrbasescal]
liststdvparagenrscalbase = gmod.liststdvparagenrscalbase[indxparagenrbasescal]
if scaltype == 'eerr':
cdfnminmparagenrscalbaseunit = gmod.cdfnminmparagenrscalbaseunit[indxparagenrbasescal]
listparagenrscalbaseunitdiff = gmod.listparagenrscalbaseunitdiff[indxparagenrbasescal]
paragenrscalbase = tdpy.icdf_eerr(paragenrunitbase, listmeanparagenrscalbase, liststdvparagenrscalbase, cdfnminmparagenrscalbaseunit, listparagenrscalbaseunitdiff)
else:
paragenrscalbase = tdpy.icdf_gaus(paragenrunitbase, listmeanparagenrscalbase, liststdvparagenrscalbase)
elif scaltype == 'pois':
paragenrscalbase = paragenrunitbase
if gdat.booldiagmode:
if not np.isfinite(paragenrscalbase).all():
print('scaltype')
print(scaltype)
print('paragenrscalbase')
print(paragenrscalbase)
print('type(paragenrscalbase)')
print(type(paragenrscalbase))
print('paragenrscalbase.dtype')
print(paragenrscalbase.dtype)
raise Exception('')
return paragenrscalbase
def icdf_trap(gdat, strgmodl, cdfn, paragenrscalfull, scalcomp, nameparagenrelem, l):
gmod = getattr(gdat, strgmodl)
if scalcomp == 'self' or scalcomp == 'powr' or scalcomp == 'dpowslopbrek' or scalcomp == 'logt':
minm = getattr(gmod.minmpara, nameparagenrelem)
if scalcomp != 'self':
maxm = getattr(gmod.maxmpara, nameparagenrelem)
if scalcomp == 'powr':
slop = paragenrscalfull[getattr(gmod.indxpara, 'slopprio%spop%d' % (nameparagenrelem, l))]
if gdat.booldiagmode:
if not np.isfinite(slop):
raise Exception('')
if maxm < minm:
raise Exception('')
icdf = tdpy.icdf_powr(cdfn, minm, maxm, slop)
if scalcomp == 'dpowslopbrek':
distbrek = paragenrscalfull[getattr(gmod.indxpara, 'brekprio' + nameparagenrelem)[l]]
sloplowr = paragenrscalfull[getattr(gmod.indxpara, 'sloplowrprio' + nameparagenrelem)[l]]
slopuppr = paragenrscalfull[getattr(gmod.indxpara, 'slopupprprio' + nameparagenrelem)[l]]
icdf = tdpy.icdf_dpow(cdfn, minm, maxm, distbrek, sloplowr, slopuppr)
if scalcomp == 'expo':
sexp = getattr(gmod, nameparagenrelem + 'distsexppop%d' % l)
icdf = tdpy.icdf_expo(cdfn, maxm, sexp)
if scalcomp == 'self':
fact = getattr(gmod.factpara, nameparagenrelem)
icdf = tdpy.icdf_self_fact(cdfn, minm, fact)
if scalcomp == 'logt':
icdf = tdpy.icdf_logt(cdfn, minm, fact)
if scalcomp == 'dexp':
scal = paragenrscalfull[getattr(gmod.indxpara, nameparagenrelem + 'distscal')[l]]
icdf = tdpy.icdf_dexp(cdfn, maxm, scal)
if scalcomp == 'lnormeanstdv':
distmean = paragenrscalfull[getattr(gmod.indxpara, nameparagenrelem + 'distmean')[l]]
diststdv = paragenrscalfull[getattr(gmod.indxpara, nameparagenrelem + 'diststdv')[l]]
icdf = tdpy.icdf_lnor(cdfn, distmean, diststdv)
if scalcomp == 'igam':
slop = paragenrscalfull[getattr(gmod.indxpara, 'slopprio' + nameparagenrelem)[l]]
cutf = getattr(gdat, 'cutf' + nameparagenrelem)
icdf = tdpy.icdf_igam(cdfn, slop, cutf)
if scalcomp == 'gaus':
distmean = paragenrscalfull[getattr(gmod.indxpara, nameparagenrelem + 'distmean')[l]]
diststdv = paragenrscalfull[getattr(gmod.indxpara, nameparagenrelem + 'diststdv')[l]]
icdf = tdpy.icdf_gaus(cdfn, distmean, diststdv)
if gdat.booldiagmode:
if not np.isfinite(icdf).all():
print('icdf')
print(icdf)
raise Exception('')
return icdf
def cdfn_trap(gdat, gdatmodi, strgmodl, icdf, indxpoplthis):
gmod = getattr(gdat, strgmodl)
gdatobjt = retr_gdatobjt(gdat, gdatmodi, strgmodl)
gmod.listscalparagenrelem = gmod.listscalparagenrelem[indxpoplthis]
cdfn = np.empty_like(icdf)
for k, nameparagenrelem in enumerate(gmod.namepara.genrelem[indxpoplthis]):
if gmod.listscalparagenrelem[k] == 'self' or gmod.listscalparagenrelem[k] == 'dexp' or gmod.listscalparagenrelem[k] == 'expo' \
or gmod.listscalparagenrelem[k] == 'powr' or gmod.listscalparagenrelem[k] == 'dpowslopbrek':
minm = getattr(gdat.fitt.minm, nameparagenrelem)
if gmod.listscalparagenrelem[k] == 'powr':
maxm = getattr(gdat.fitt.maxm, nameparagenrelem)
slop = gdatobjt.this.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'slop')[indxpoplthis]]
cdfn[k] = cdfn_powr(icdf[k], minm, maxm, slop)
elif gmod.listscalparagenrelem[k] == 'dpowslopbrek':
maxm = getattr(gdat.fitt.maxm, nameparagenrelem)
brek = gdatobjt.this.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'distbrek')[indxpoplthis]]
sloplowr = gdatobjt.this.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'sloplowr')[indxpoplthis]]
slopuppr = gdatobjt.this.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'slopuppr')[indxpoplthis]]
cdfn[k] = cdfn_dpow(icdf[k], minm, maxm, brek, sloplowr, slopuppr)
else:
fact = getattr(gdat.fitt, 'fact' + nameparagenrelem)
cdfn[k] = cdfn_self(icdf[k], minm, fact)
if gmod.listscalparagenrelem[k] == 'lnormeanstdv':
distmean = gdatmodi.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'distmean')[indxpoplthis]]
diststdv = gdatmodi.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'diststdv')[indxpoplthis]]
cdfn[k] = cdfn_lnor(icdf[k], distmean, slop)
if gmod.listscalparagenrelem[k] == 'igam':
slop = gdatmodi.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'slop')[indxpoplthis]]
cutf = getattr(gdat, 'cutf' + nameparagenrelem)
cdfn[k] = cdfn_igam(icdf[k], slop, cutf)
if gmod.listscalparagenrelem[k] == 'gaus':
distmean = gdatmodi.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'distmean')[indxpoplthis]]
diststdv = gdatmodi.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'diststdv')[indxpoplthis]]
cdfn[k] = cdfn_gaus(icdf[k], distmean, diststdv)
return cdfn
### update sampler state
def updt_stat(gdat, gdatmodi):
if gdat.typeverb > 1:
print('updt_stat()')
# update the sample and the unit sample vectors
gdatmodi.this.lpritotl = gdatmodi.next.lpritotl
gdatmodi.this.lliktotl = gdatmodi.next.lliktotl
gdatmodi.this.lpostotl = gdatmodi.next.lpostotl
gdatmodi.this.paragenrscalfull[gdatmodi.indxsampmodi] = np.copy(gdatmodi.next.paragenrscalfull[gdatmodi.indxsampmodi])
gdatmodi.this.paragenrunitfull[gdatmodi.indxsampmodi] = np.copy(gdatmodi.next.paragenrunitfull[gdatmodi.indxsampmodi])
if gdatmodi.this.indxproptype > 0:
gdatmodi.this.indxelemfull = deepcopy(gdatmodi.next.indxelemfull)
gdatmodi.this.indxparagenrfullelem = retr_indxparagenrfullelem(gdat, gdatmodi.this.indxelemfull, 'fitt')
def initcompfromstat(gdat, gdatmodi, namerefr):
for l in gmod.indxpopl:
for g, nameparagenrelem in enumerate(gmod.namepara.genrelem[l]):
minm = getattr(gdat.fitt.minmpara, nameparagenrelem)
maxm = getattr(gdat.fitt.maxmpara, nameparagenrelem)
try:
comp = getattr(gdat, namerefr + nameparagenrelem)[l][0, :]
if gmod.listscalparagenrelem[l][g] == 'self' or gmod.listscalparagenrelem[l][g] == 'logt':
fact = getattr(gdat.fitt, 'fact' + nameparagenrelem)
if gmod.listscalparagenrelem[l][g] == 'self':
compunit = cdfn_self(comp, minm, fact)
if gmod.listscalparagenrelem[l][g] == 'logt':
compunit = cdfn_logt(comp, minm, fact)
if gmod.listscalparagenrelem[l][g] == 'expo':
scal = getattr(gdat.fitt, 'gangdistsexp')
maxm = getattr(gdat.fitt.maxm, nameparagenrelem)
compunit = cdfn_expo(icdf, maxm, scal)
if gmod.listscalparagenrelem[l][g] == 'powr' or gmod.listscalparagenrelem[l][g] == 'igam':
slop = gdatmodi.this.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'slop')[l]]
if gmod.listscalparagenrelem[l][g] == 'powr':
compunit = cdfn_powr(comp, minm, maxm, slop)
if gmod.listscalparagenrelem[l][g] == 'igam':
cutf = getattr(gdat, 'cutf' + nameparagenrelem)
compunit = cdfn_igam(comp, slop, cutf)
if gmod.listscalparagenrelem[l][g] == 'dpowslopbrek':
brek = gdatmodi.this.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'distbrek')[l]]
sloplowr = gdatmodi.this.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'sloplowr')[l]]
slopuppr = gdatmodi.this.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'slopuppr')[l]]
compunit = cdfn_powr(comp, minm, maxm, brek, sloplowr, slopuppr)
if gmod.listscalparagenrelem[l][g] == 'gaus':
distmean = gdatmodi.this.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'distmean')[l]]
diststdv = gdatmodi.this.paragenrscalfull[getattr(gdat.fitt, 'indxparagenrbase' + nameparagenrelem + 'diststdv')[l]]
compunit = cdfn_gaus(comp, distmean, diststdv)
except:
if gdat.typeverb > 0:
print('Initialization from the reference catalog failed for %s. Sampling randomly...' % nameparagenrelem)
compunit = np.random.rand(gdatmodi.this.paragenrscalfull[gmod.indxpara.numbelem[l]].astype(int))
gdatmodi.this.paragenrunitfull[gdatmodi.this.indxparagenrfullelem[l][nameparagenrelem]] = compunit
### find the set of pixels in proximity to a position on the map
def retr_indxpixlelemconc(gdat, strgmodl, dictelem, l):
gmod = getattr(gdat, strgmodl)
lgal = dictelem[l]['lgal']
bgal = dictelem[l]['bgal']
varbampl = dictelem[l][gmod.nameparagenrelemampl[l]]
if gmod.typeelemspateval[l] == 'locl':
listindxpixlelem = [[] for k in range(lgal.size)]
for k in range(lgal.size):
indxpixlpnts = retr_indxpixl(gdat, bgal[k], lgal[k])
indxfluxproxtemp = np.digitize(varbampl[k], gdat.binspara.prox)
if indxfluxproxtemp > 0:
indxfluxproxtemp -= 1
if indxfluxproxtemp == gdat.binspara.prox.size - 1:
print('Warning! Index of the proximity pixel list overflew. Taking the largest list...')
indxfluxproxtemp -= 1
indxpixlelem = gdat.indxpixlprox[indxfluxproxtemp][indxpixlpnts]
if isinstance(indxpixlelem, int):
indxpixlelem = gdat.indxpixl
listindxpixlelem[k] = indxpixlelem
listindxpixlelemconc = np.unique(np.concatenate(listindxpixlelem))
else:
listindxpixlelemconc = gdat.indxpixl
listindxpixlelem = gdat.indxpixl
return listindxpixlelem, listindxpixlelemconc
### find the distance between two points on the map
def retr_angldistunit(gdat, lgal, bgal, indxpixlelem, retranglcosi=False):
if gdat.typepixl == 'heal':
xdat, ydat, zaxi = retr_unit(lgal, bgal)
anglcosi = gdat.xdatgrid[indxpixlelem] * xdat + gdat.ydatgrid[indxpixlelem] * ydat + gdat.zaxigrid[indxpixlelem] * zaxi
if retranglcosi:
return anglcosi
else:
angldist = np.arccos(anglcosi)
return angldist
else:
angldist = np.sqrt((lgal - gdat.lgalgrid[indxpixlelem])**2 + (bgal - gdat.bgalgrid[indxpixlelem])**2)
return angldist
### find the pixel index of a point on the map
def retr_indxpixl(gdat, bgal, lgal):
if gdat.typepixl == 'heal':
indxpixl = gdat.pixlcnvt[hp.ang2pix(gdat.numbsideheal, np.pi / 2. - bgal, lgal)]
if gdat.booldiagmode:
if (indxpixl == -1).any():
raise Exception('pixlcnvt went negative!')
if gdat.typepixl == 'cart':
indxlgcr = np.floor(gdat.numbsidecart * (lgal - gdat.minmlgaldata) / 2. / gdat.maxmgangdata).astype(int)
indxbgcr = np.floor(gdat.numbsidecart * (bgal - gdat.minmbgaldata) / 2. / gdat.maxmgangdata).astype(int)
if np.isscalar(indxlgcr):
if indxlgcr < 0:
indxlgcr = 0
if indxlgcr >= gdat.numbsidecart:
indxlgcr = gdat.numbsidecart - 1
else:
indxlgcr[np.where(indxlgcr < 0)] = 0
indxlgcr[np.where(indxlgcr >= gdat.numbsidecart)] = gdat.numbsidecart - 1
if np.isscalar(indxbgcr):
if indxbgcr < 0:
indxbgcr = 0
if indxbgcr >= gdat.numbsidecart:
indxbgcr = gdat.numbsidecart - 1
else:
indxbgcr[np.where(indxbgcr < 0)] = 0
indxbgcr[np.where(indxbgcr >= gdat.numbsidecart)] = gdat.numbsidecart - 1
indxpixl = indxlgcr * gdat.numbsidecart + indxbgcr
# convert to an index of non-zero exposure pixels
#indxpixl = gdat.indxpixlroficnvt[indxpixl]
return indxpixl
## obtain count maps
def retr_cntp(gdat, sbrt):
cntp = sbrt * gdat.expo * gdat.apix
if gdat.enerdiff:
cntp *= gdat.deltener[:, None, None]
return cntp
## plotting
### construct path for plots
def retr_plotpath(gdat, gdatmodi, strgpdfn, strgstat, strgmodl, strgplot, nameinte=''):
if strgmodl == 'true' or strgstat == '':
path = gdat.pathinit + nameinte + strgplot + '.pdf'
elif strgstat == 'pdfn' or strgstat == 'mlik':
path = gdat.pathplotrtag + strgpdfn + '/finl/' + nameinte + strgstat + strgplot + '.pdf'
elif strgstat == 'this':
path = gdat.pathplotrtag + strgpdfn + '/fram/' + nameinte + strgstat + strgplot + '_swep%09d.pdf' % gdatmodi.cntrswep
return path
### determine the marker size
def retr_mrkrsize(gdat, strgmodl, compampl, nameparagenrelemampl):
gmod = getattr(gdat, strgmodl)
minm = getattr(gdat.minmpara, nameparagenrelemampl)
maxm = getattr(gdat.maxmpara, nameparagenrelemampl)
mrkrsize = (np.sqrt(compampl) - np.sqrt(minm)) / (np.sqrt(maxm) - np.sqrt(minm)) * (gdat.maxmmrkrsize - gdat.minmmrkrsize) + gdat.minmmrkrsize
return mrkrsize
## experiment specific
def retr_psfphubb(gmod):
# temp
gmod.psfpexpr = np.array([0.080, 0.087]) / gdat.anglfact
def retr_psfpchan(gmod):
# temp
#gmod.psfpexpr = np.array([0.25, 0.3, 0.4, 0.6, 0.7]) / gdat.anglfact
if gdat.numbenerfull == 5:
gmod.psfpexpr = np.array([0.424 / gdat.anglfact, 2.75, 0.424 / gdat.anglfact, 2.59, 0.440 / gdat.anglfact, 2.47, 0.457 / gdat.anglfact, 2.45, 0.529 / gdat.anglfact, 3.72])
if gdat.numbenerfull == 2:
gmod.psfpexpr = np.array([0.427 / gdat.anglfact, 2.57, 0.449 / gdat.anglfact, 2.49])
#gdat.psfpchan = gmod.psfpexpr[(2 * gdat.indxenerincl[:, None] + np.arange(2)[None, :]).flatten()]
#gmod.psfpexpr = np.array([0.25 / gdat.anglfact,
# 0.30 / gdat.anglfacti\
# 0.40 / gdat.anglfacti\
# 0.60 / gdat.anglfacti\
# 0.70 / gdat.anglfacti
#gmod.psfpexpr = np.array([0.35 / gdat.anglfact, 2e-1, 1.9, 0.5 / gdat.anglfact, 1.e-1, 2.])
#gmod.psfpexpr = np.array([0.25 / gdat.anglfact, 2.0e-1, 1.9, \
# 0.30 / gdat.anglfact, 1.0e-1, 2.0, \
# 0.40 / gdat.anglfact, 1.0e-1, 2.0, \
# 0.60 / gdat.anglfact, 1.0e-1, 2.0, \
# 0.70 / gdat.anglfact, 1.0e-1, 2.0])
def retr_psfpsdyn(gmod):
gmod.psfpexpr = np.array([0.05])
def retr_psfpferm(gmod):
if gdat.anlytype.startswith('rec8'):
path = gdat.pathdata + 'expr/irfn/psf_P8R2_SOURCE_V6_PSF.fits'
else:
path = gdat.pathdata + 'expr/irfn/psf_P7REP_SOURCE_V15_back.fits'
irfn = astropy.io.fits.getdata(path, 1)
minmener = irfn['energ_lo'].squeeze() * 1e-3 # [GeV]
maxmener = irfn['energ_hi'].squeeze() * 1e-3 # [GeV]
enerirfn = np.sqrt(minmener * maxmener)
numbpsfpscal = 3
numbpsfpform = 5
fermscal = np.zeros((gdat.numbevtt, numbpsfpscal))
fermform = np.zeros((gdat.numbener, gdat.numbevtt, numbpsfpform))
strgpara = ['score', 'gcore', 'stail', 'gtail', 'ntail']
for m in gdat.indxevtt:
if gdat.anlytype.startswith('rec8'):
irfn = astropy.io.fits.getdata(path, 1 + 3 * gdat.indxevttincl[m])
fermscal[m, :] = astropy.io.fits.getdata(path, 2 + 3 * gdat.indxevttincl[m])['PSFSCALE']
else:
if m == 1:
path = gdat.pathdata + 'expr/irfn/psf_P7REP_SOURCE_V15_front.fits'
elif m == 0:
path = gdat.pathdata + 'expr/irfn/psf_P7REP_SOURCE_V15_back.fits'
else:
continue
irfn = astropy.io.fits.getdata(path, 1)
fermscal[m, :] = astropy.io.fits.getdata(path, 2)['PSFSCALE']
for k in range(numbpsfpform):
fermform[:, m, k] = sp.interpolate.interp1d(enerirfn, np.mean(irfn[strgpara[k]].squeeze(), axis=0), fill_value='extrapolate')(gdat.meanpara.ener)
# convert N_tail to f_core
for m in gdat.indxevtt:
for i in gdat.indxener:
fermform[i, m, 4] = 1. / (1. + fermform[i, m, 4] * fermform[i, m, 2]**2 / fermform[i, m, 0]**2)
# calculate the scale factor
gdat.fermscalfact = np.sqrt((fermscal[None, :, 0] * (10. * gdat.meanpara.ener[:, None])**fermscal[None, :, 2])**2 + fermscal[None, :, 1]**2)
# store the fermi PSF parameters
gmod.psfpexpr = np.zeros(gdat.numbener * gdat.numbevtt * numbpsfpform)
for m in gdat.indxevtt:
for k in range(numbpsfpform):
indxfermpsfptemp = m * numbpsfpform * gdat.numbener + gdat.indxener * numbpsfpform + k
gmod.psfpexpr[indxfermpsfptemp] = fermform[:, m, k]
def retr_refrchaninit(gdat):
gdat.indxrefr = np.arange(gdat.numbrefr)
gdat.dictrefr = []
for q in gdat.indxrefr:
gdat.dictrefr.append(dict())
gdat.refr.namepara.elemsign = ['flux', 'magt']
gdat.refr.lablelem = ['Xue+2011', 'Wolf+2008']
gdat.listnamerefr += ['xu11', 'wo08']
setattr(gdat, 'plotminmotyp', 0.)
setattr(gdat, 'plottmaxmotyp', 1.)
setattr(gmod.lablrootpara, 'otyp', 'O')
setattr(gdat, 'scalotypplot', 'self')
setattr(gmod.lablrootpara, 'otypxu11', 'O')
for name in gdat.listnamerefr:
setattr(gdat, 'plotminmotyp' + name, 0.)
setattr(gdat, 'plotmaxmotyp' + name, 1.)
if gdat.strgcnfg == 'pcat_chan_inpt_home4msc':
with open(gdat.pathinpt + 'ECDFS_Cross_ID_Hsu2014.txt', 'r') as thisfile:
for k, line in enumerate(thisfile):
if k < 18:
continue
rasccand =line[2]
declcand =line[2]
gdat.refr.namepara.elem[0] += ['lgal', 'bgal', 'flux', 'sind', 'otyp', 'lumi']
gdat.refr.namepara.elem[1] += ['lgal', 'bgal', 'magt', 'reds', 'otyp']
def retr_refrchanfinl(gdat):
booltemp = False
if gdat.anlytype.startswith('extr'):
if gdat.numbsidecart == 300:
gdat.numbpixllgalshft[0] = 1490
gdat.numbpixlbgalshft[0] = 1430
else:
booltemp = True
elif gdat.anlytype.startswith('home'):
gdat.numbpixllgalshft[0] = 0
gdat.numbpixlbgalshft[0] = 0
if gdat.numbsidecart == 600:
pass
elif gdat.numbsidecart == 100:
indxtile = int(gdat.anlytype[-4:])
numbsidecntr = int(gdat.anlytype[8:12])
numbtileside = numbsidecntr / gdat.numbsidecart
indxtilexaxi = indxtile // numbtileside
indxtileyaxi = indxtile % numbtileside
gdat.numbpixllgalshft[0] += indxtilexaxi * gdat.numbsidecart
gdat.numbpixlbgalshft[0] += indxtileyaxi * gdat.numbsidecart
elif gdat.numbsidecart == 300:
gdat.numbpixllgalshft[0] += 150
gdat.numbpixlbgalshft[0] += 150
else:
booltemp = True
else:
booltemp = True
if booltemp:
raise Exception('Reference elements cannot be aligned with the spatial axes!')
## WCS object for rotating reference elements into the ROI
if gdat.numbener == 2:
gdat.listpathwcss[0] = gdat.pathinpt + 'CDFS-4Ms-0p5to2-asca-im-bin1.fits'
else:
gdat.listpathwcss[0] = gdat.pathinpt + '0.5-0.91028_flux_%sMs.img' % gdat.anlytype[4]
# Xue et al. (2011)
#with open(gdat.pathinpt + 'chancatl.txt', 'r') as thisfile:
pathfile = gdat.pathinpt + 'Xue2011.fits'
hdun = pf.open(pathfile)
hdun.info()
lgalchan = hdun[1].data['_Glon'] / 180. * pi
bgalchan = hdun[1].data['_Glat'] / 180. * pi
fluxchansoft = hdun[1].data['SFlux']
fluxchanhard = hdun[1].data['HFlux']
objttypechan = hdun[1].data['Otype']
gdat.refrlumi[0][0] = hdun[1].data['Lx']
# position
gdat.refr.dictelem[0]['lgal'] = lgalchan
gdat.refr.dictelem[0]['bgal'] = bgalchan
# spectra
gdat.refrspec = [[np.zeros((3, gdat.numbener, lgalchan.size))]]
if gdat.numbener == 2:
gdat.refrspec[0][0, 0, :] = fluxchansoft * 0.624e9
gdat.refrspec[0][0, 1, :] = fluxchanhard * 0.624e9 / 16.
else:
gdat.refrspec[0][0, :, :] = 2. * fluxchansoft[None, :] * 0.624e9
gdat.refrspec[0][1, :, :] = gdat.refrspec[0][0, :, :]
gdat.refrspec[0][2, :, :] = gdat.refrspec[0][0, :, :]
# fluxes
gdat.refrflux[0] = gdat.refrspec[0][:, gdat.indxenerpivt, :]
# spectral indices
if gdat.numbener > 1:
gdat.refrsind[0] = -np.log(gdat.refrspec[0][0, 1, :] / gdat.refrspec[0][0, 0, :]) / np.log(np.sqrt(7. / 2.) / np.sqrt(0.5 * 2.))
## object type
objttypechantemp = np.zeros(lgalchan.size) - 1.
indx = np.where(objttypechan == 'AGN')[0]
objttypechantemp[indx] = 0.165
indx = np.where(objttypechan == 'Galaxy')[0]
objttypechantemp[indx] = 0.495
indx = np.where(objttypechan == 'Star')[0]
objttypechantemp[indx] = 0.835
gdat.refrotyp[0][0] = objttypechantemp
# Wolf et al. (2011)
path = gdat.pathdata + 'inpt/Wolf2008.fits'
data = astropy.io.fits.getdata(path)
gdat.refrlgal[1] = np.deg2rad(data['_Glon'])
gdat.refrlgal[1] = ((gdat.refrlgal[1] - pi) % (2. * pi)) - pi
gdat.refrbgal[1] = np.deg2rad(data['_Glat'])
gdat.refrmagt[1][0] = data['Rmag']
gdat.refrreds[1][0] = data['MCz']
#listname = []
#for k in range(data['MCclass'].size):
# if not data['MCclass'][k] in listname:
# listname.append(data['MCclass'][k])
listname = ['Galaxy', 'Galaxy (Uncl!)', 'QSO (Gal?)', 'Galaxy (Star?)', 'Star', 'Strange Object', 'QSO', 'WDwarf']
gdat.refrotyp[1][0] = np.zeros_like(gdat.refrreds[1][0]) - 1.
for k, name in enumerate(listname):
indx = np.where(data['MCclass'] == name)[0]
gdat.refrotyp[1][0][indx] = k / 10.
# error budget
for name in ['lgal', 'bgal', 'sind', 'otyp', 'lumi', 'magt', 'reds']:
refrtile = [[] for q in gdat.indxrefr]
refrfeat = getattr(gdat.refr, name)
for q in gdat.indxrefr:
if len(refrfeat[q]) > 0:
refrtile[q] = np.tile(refrfeat[q], (3, 1))
setattr(gdat.refr, name, refrtile)
def retr_refrferminit(gdat):
gdat.listnamerefr += ['ac15', 'ma05']
gdat.indxrefr = np.arange(gdat.numbrefr)
gdat.refr.lablelem = ['Acero+2015', 'Manchester+2005']
gdat.refr.namepara.elemsign = ['flux', 'flux0400']
setattr(gmod.lablrootpara, 'curvac15', '%s_{3FGL}' % gdat.lablcurv)
setattr(gmod.lablrootpara, 'expcac15', 'E_{c,3FGL}')
for name in gdat.listnamerefr:
setattr(gdat.minmpara, 'curv' + name, -1.)
setattr(gdat.maxmpara, 'curv' + name, 1.)
setattr(gdat.minmpara, 'expc' + name, 0.1)
setattr(gdat.maxmpara, 'expc' + name, 10.)
gdat.refr.namepara.elem[0] += ['lgal', 'bgal', 'flux', 'sind', 'curv', 'expc', 'tvar', 'etag', 'styp', 'sindcolr0001', 'sindcolr0002']
gdat.refr.namepara.elem[1] += ['lgal', 'bgal', 'flux0400', 'per0', 'per1']
def retr_refrfermfinl(gdat):
gdat.minmstyp = -0.5
gdat.maxmstyp = 3.5
gdat.lablstyp = 'S'
gmod.scalstypplot = 'self'
gdat.minmtvar = 0.
gdat.maxmtvar = 400.
gdat.labltvar = 'T'
gmod.scaltvarplot = 'logt'
# Acero+2015
path = gdat.pathdata + 'expr/pnts/gll_psc_v16.fit'
fgl3 = astropy.io.fits.getdata(path)
gdat.refr.dictelem[0]['lgal'] = np.deg2rad(fgl3['glon'])
gdat.refr.dictelem[0]['lgal'] = np.pi - ((gdat.refr.dictelem[0]['lgal'] - np.pi) % (2. * np.pi))
gdat.refr.dictelem[0]['bgal'] = np.deg2rad(fgl3['glat'])
gdat.refr.numbelemfull = gdat.refr.dictelem[0]['lgal'].size
gdat.refrspec = [np.empty((3, gdat.numbener, gdat.refr.dictelem[0]['lgal'].size))]
gdat.refrspec[0][0, :, :] = np.stack((fgl3['Flux300_1000'], fgl3['Flux1000_3000'], fgl3['Flux3000_10000']))[gdat.indxenerincl, :] / gdat.deltener[:, None]
fgl3specstdvtemp = np.stack((fgl3['Unc_Flux100_300'], fgl3['Unc_Flux300_1000'], fgl3['Unc_Flux1000_3000'], fgl3['Unc_Flux3000_10000'], \
fgl3['Unc_Flux10000_100000']))[gdat.indxenerincl, :, :] / gdat.deltener[:, None, None]
gdat.refrspec[0][1, :, :] = gdat.refrspec[0][0, :, :] + fgl3specstdvtemp[:, :, 0]
gdat.refrspec[0][2, :, :] = gdat.refrspec[0][0, :, :] + fgl3specstdvtemp[:, :, 1]
gdat.refrspec[0][np.where(np.isfinite(gdat.refrspec[0]) == False)] = 0.
gdat.refrflux[0] = gdat.refrspec[0][:, gdat.indxenerpivt, :]
gdat.refrsindcolr0001[0] = -np.log(gdat.refrspec[0][:, 1, :] / gdat.refrflux[0]) / np.log(gdat.meanpara.ener[1] / gdat.enerpivt)
gdat.refrsindcolr0002[0] = -np.log(gdat.refrspec[0][:, 2, :] / gdat.refrflux[0]) / np.log(gdat.meanpara.ener[2] / gdat.enerpivt)
fgl3axisstdv = (fgl3['Conf_68_SemiMinor'] + fgl3['Conf_68_SemiMajor']) * 0.5
fgl3anglstdv = np.deg2rad(fgl3['Conf_68_PosAng']) # [rad]
fgl3lgalstdv = fgl3axisstdv * abs(np.cos(fgl3anglstdv))
fgl3bgalstdv = fgl3axisstdv * abs(np.sin(fgl3anglstdv))
gdat.refretag[0] = np.zeros(gdat.refr.dictelem[0]['lgal'].size, dtype=object)
for k in range(gdat.refr.dictelem[0]['lgal'].size):
gdat.refretag[0][k] = '%s, %s, %s' % (fgl3['Source_Name'][k], fgl3['CLASS1'][k], fgl3['ASSOC1'][k])
gdat.refrtvar[0] = fgl3['Variability_Index']
gdat.refrstyp[0] = np.zeros_like(gdat.refr.dictelem[0]['lgal']) - 1
gdat.refrstyp[0][np.where(fgl3['SpectrumType'] == 'PowerLaw ')] = 0
gdat.refrstyp[0][np.where(fgl3['SpectrumType'] == 'LogParabola ')] = 1
gdat.refrstyp[0][np.where(fgl3['SpectrumType'] == 'PLExpCutoff ')] = 2
gdat.refrstyp[0][np.where(fgl3['SpectrumType'] == 'PLSuperExpCutoff')] = 3
indx = np.where(gdat.refrstyp[0] == -1)[0]
if indx.size > 0:
raise Exception('')
gdat.refrsind[0] = fgl3['Spectral_Index']
gdat.refrcurv[0] = fgl3['beta']
gdat.refrexpc[0] = fgl3['Cutoff'] * 1e-3
gdat.refrcurv[0][np.where(np.logical_not(np.isfinite(gdat.refrcurv[0])))] = -10.
gdat.refrexpc[0][np.where(np.logical_not(np.isfinite(gdat.refrexpc[0])))] = 0.
gdat.refrsind[0] = np.tile(gdat.refrsind[0], (3, 1))
gdat.refrcurv[0] = np.tile(gdat.refrcurv[0], (3, 1))
gdat.refrexpc[0] = np.tile(gdat.refrexpc[0], (3, 1))
# Manchester+2005
path = gdat.pathdata + 'inpt/Manchester2005.fits'
data = astropy.io.fits.getdata(path)
gdat.refrlgal[1] = np.deg2rad(data['glon'])
gdat.refrlgal[1] = ((gdat.refrlgal[1] - np.pi) % (2. * np.pi)) - np.pi
gdat.refrbgal[1] = np.deg2rad(data['glat'])
gdat.refrper0[1] = data['P0']
gdat.refrper1[1] = data['P1']
gdat.refrflux0400[1] = data['S400']
#gdat.refrdism[1] = data['DM']
#gdat.refrdlos[1] = data['Dist']
# error budget
for name in ['lgal', 'bgal', 'per0', 'per1', 'flux0400', 'tvar', 'styp']:
refrtile = [[] for q in gdat.indxrefr]
refrfeat = getattr(gdat.refr, name)
for q in gdat.indxrefr:
if len(refrfeat[q]) > 0:
refrtile[q] = np.tile(refrfeat[q], (3, 1))
setattr(gdat.refr, name, refrtile)
def retr_singgaus(scaldevi, sigc):
psfn = 1. / 2. / np.pi / sigc**2 * np.exp(-0.5 * scaldevi**2 / sigc**2)
return psfn
def retr_singking(scaldevi, sigc, gamc):
psfn = 1. / 2. / np.pi / sigc**2 * (1. - 1. / gamc) * (1. + scaldevi**2 / 2. / gamc / sigc**2)**(-gamc)
return psfn
def retr_doubgaus(scaldevi, frac, sigc, sigt):
psfn = frac / 2. / np.pi / sigc**2 * np.exp(-0.5 * scaldevi**2 / sigc**2) + (1. - frac) / 2. / np.pi / sigc**2 * np.exp(-0.5 * scaldevi**2 / sigc**2)
return psfn
def retr_gausking(scaldevi, frac, sigc, sigt, gamt):
psfn = frac / 2. / np.pi / sigc**2 * np.exp(-0.5 * scaldevi**2 / sigc**2) + (1. - frac) / 2. / np.pi / sigt**2 * (1. - 1. / gamt) * (1. + scaldevi**2 / 2. / gamt / sigt**2)**(-gamt)
return psfn
def retr_doubking(scaldevi, frac, sigc, gamc, sigt, gamt):
psfn = frac / 2. / np.pi / sigc**2 * (1. - 1. / gamc) * (1. + scaldevi**2 / 2. / gamc / sigc**2)**(-gamc) + \
(1. - frac) / 2. / np.pi / sigt**2 * (1. - 1. / gamt) * (1. + scaldevi**2 / 2. / gamt / sigt**2)**(-gamt)
return psfn
def retr_lgalbgal(gang, aang):
lgal = gang * np.cos(aang)
bgal = gang * np.sin(aang)
return lgal, bgal
def retr_gang(lgal, bgal):
gang = np.arccos(np.cos(lgal) * np.cos(bgal))
return gang
def retr_aang(lgal, bgal):
aang = np.arctan2(bgal, lgal)
return aang
def show_paragenrscalfull(gdat, gdatmodi, strgstat='this', strgmodl='fitt', indxsampshow=None):
gmod = getattr(gdat, strgmodl)
gdatobjt = retr_gdatobjt(gdat, gdatmodi, strgmodl)
gmodstat = getattr(gdatobjt, strgstat)
print('strgmodl: ' + strgmodl)
print('strgstat: ' + strgstat)
print('%5s %20s %30s %30s %15s' % ('index', 'namepara', 'paragenrunitfull', 'paragenrscalfull', 'scalpara'))
for k in gmod.indxparagenrfull:
if indxsampshow is not None and not k in indxsampshow:
continue
if gmod.numbparaelem > 0:
booltemp = False
for l in gmod.indxpopl:
if k == gmod.indxparagenrelemsing[l][0]:
booltemp = True
if booltemp:
print('')
print('%5d %20s %30g %30g %15s' % (k, gmod.namepara.genrfull[k], gmodstat.paragenrunitfull[k], gmodstat.paragenrscalfull[k], gmod.scalpara.genrfull[k]))
def prop_stat(gdat, gdatmodi, strgmodl, thisindxelem=None, thisindxpopl=None, brth=False, deth=False):
if gdat.typeverb > 1:
print('prop_stat()')
#indxproptype
# within, birth, death, split, merge
# 0, 1, 2, 3, 4
gmod = getattr(gdat, strgmodl)
gdatobjt = retr_gdatobjt(gdat, gdatmodi, strgmodl)
gmodthis = getattr(gdatobjt, 'this')
gmodnext = getattr(gdatobjt, 'next')
if gmod.numbparaelem > 0:
if gdat.booldiagmode:
for l in gmod.indxpopl:
if len(gmodthis.indxelemfull[l]) > len(set(gmodthis.indxelemfull[l])):
raise Exception('Repeating entry in the element index list!')
thisindxparagenrfullelem = retr_indxparagenrfullelem(gdat, gmodthis.indxelemfull, strgmodl)
setattr(gmodthis, 'indxparagenrfullelem', thisindxparagenrfullelem)
else:
thisindxparagenrfullelem = None
gdatmodi.this.boolpropfilt = True
# index of the population in which a transdimensional proposal will be attempted
if gmod.numbparaelem > 0:
if thisindxpopl is None:
gdatmodi.indxpopltran = np.random.choice(gmod.indxpopl)
else:
gdatmodi.indxpopltran = thisindxpopl
numbelemtemp = gmodthis.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]]
# forced death or birth does not check for the prior on the dimensionality on purpose!
if gmod.numbparaelem > 0 and (deth or brth or np.random.rand() < gdat.probtran) and \
not (numbelemtemp == gmod.minmpara.numbelem[gdatmodi.indxpopltran] and numbelemtemp == gmod.maxmpara.numbelem[gdatmodi.indxpopltran]):
if brth or deth or np.random.rand() < gdat.probbrde or \
numbelemtemp == gmod.maxmpara.numbelem[gdatmodi.indxpopltran] and numbelemtemp == 1 or numbelemtemp == 0:
## births and deaths
if numbelemtemp == gmod.maxmpara.numbelem[gdatmodi.indxpopltran] or deth:
gdatmodi.this.indxproptype = 2
elif numbelemtemp == gmod.minmpara.numbelem[gdatmodi.indxpopltran] or brth:
gdatmodi.this.indxproptype = 1
else:
if np.random.rand() < 0.5:
gdatmodi.this.indxproptype = 1
else:
gdatmodi.this.indxproptype = 2
else:
## splits and merges
if numbelemtemp == gmod.minmpara.numbelem[gdatmodi.indxpopltran] or numbelemtemp < 2:
gdatmodi.this.indxproptype = 3
elif numbelemtemp == gmod.maxmpara.numbelem[gdatmodi.indxpopltran]:
gdatmodi.this.indxproptype = 4
else:
if np.random.rand() < 0.5:
gdatmodi.this.indxproptype = 3
else:
gdatmodi.this.indxproptype = 4
else:
if gdat.booldiagmode and (gdatmodi.stdp > 1e2).any():
raise Exception('')
thisindxparagenrfullelemconc = []
for l in gmod.indxpopl:
thisindxparagenrfullelemconc.append(thisindxparagenrfullelem[l]['full'])
# get the indices of the current parameter vector
if gmod.numbparaelem > 0:
thisindxsampfull = np.concatenate([gmod.indxparagenrbasestdv] + thisindxparagenrfullelemconc)
else:
thisindxsampfull = gmod.indxparagenrbasestdv
thisstdp = gdatmodi.stdp[gdat.indxstdppara[thisindxsampfull]]
if not np.isfinite(thisstdp).all():
raise Exception('')
gdatmodi.this.indxproptype = 0
if gdat.booldiagmode and gdat.probspmr == 0 and gdatmodi.this.indxproptype > 2:
raise Exception('')
if gdat.typeverb > 1:
print('gdatmodi.this.indxproptype')
print(gdatmodi.this.indxproptype)
if gdatmodi.this.indxproptype == 0:
gmodnext.paragenrunitfull = np.copy(gmodthis.paragenrunitfull)
if gmod.numbparaelem > 0:
gmodnext.indxelemfull = gmodthis.indxelemfull
if gdatmodi.this.indxproptype > 0:
gmodnext.paragenrunitfull = np.copy(gmodthis.paragenrunitfull)
gmodnext.paragenrscalfull = np.copy(gmodthis.paragenrscalfull)
if gmod.numbparaelem > 0:
gmodnext.indxelemfull = deepcopy(gmodthis.indxelemfull)
if gdatmodi.this.indxproptype == 0:
## proposal scale
if False:
# amplitude-dependent proposal scale
for l in gmod.indxpopl:
thiscompampl = gmodthis.paragenrscalfull[thisindxparagenrfullelem[indxelemfull][gmod.nameparagenrelemampl[l]][l]]
compampl = gmodnext.paragenrscalfull[thisindxparagenrfullelem[gmod.nameparagenrelemampl[l]][l][indxelemfull]]
minmcompampl = getattr(gmod.minmpara, gmod.nameparagenrelemampl[l])
thiscompunit = gmodthis.paragenrscalfull[thisindxparagenrfullelem[gmod.nameparagenrelemampl[l]][l][indxelemfull]]
compunit = gmodnext.paragenrscalfull[thisindxparagenrfullelem[gmod.nameparagenrelemampl[l]][l][indxelemfull]]
if nameparagenrelem == gmod.nameparagenrelemampl[l]:
# temp -- this only works if compampl is powr distributed
gdatmodi.this.stdp = stdpcomp / (thiscompampl / minmcompampl)**2.
gdatmodi.this.stdv = stdpcomp / (compampl / minmcompampl)**2.
gdatmodi.this.ltrp += np.sum(0.5 * (nextcompunit - thiscompunit)**2 * (1. / gdatmodi.this.stdv**2 - 1. / gdatmodi.this.stdv**2))
else:
gdatmodi.this.stdp = stdpcomp / (np.minimum(thiscompampl, compampl) / minmcompampl)**0.5
## propose a step
diffparagenrunitfull = np.random.normal(size=thisindxsampfull.size) * thisstdp
gmodnext.paragenrunitfull[thisindxsampfull] = gmodthis.paragenrunitfull[thisindxsampfull] + diffparagenrunitfull
if gdat.booldiagmode:
if (gmodnext.paragenrunitfull[gmod.numbpopl:] == 1).any():
raise Exception('')
if (gmodnext.paragenrunitfull[gmod.numbpopl:] == 0).any():
raise Exception('')
if not np.isfinite(gmodnext.paragenrunitfull).all():
raise Exception('')
indxsamplowr = np.where(gmodnext.paragenrunitfull[gmod.numbpopl:] < 0.)[0]
if indxsamplowr.size > 0:
gmodnext.paragenrunitfull[gmod.numbpopl+indxsamplowr] = abs(gmodnext.paragenrunitfull[gmod.numbpopl+indxsamplowr]) % 1.
if gdat.booldiagmode:
if (gmodnext.paragenrunitfull[gmod.numbpopl:] == 1).any():
raise Exception('')
if (gmodnext.paragenrunitfull[gmod.numbpopl:] == 0).any():
raise Exception('')
indxsampuppr = np.where(gmodnext.paragenrunitfull[gmod.numbpopl:] > 1.)[0]
if indxsampuppr.size > 0:
gmodnext.paragenrunitfull[gmod.numbpopl+indxsampuppr] = (gmodnext.paragenrunitfull[gmod.numbpopl+indxsampuppr] - 1.) % 1.
if gdat.booldiagmode:
if (gmodnext.paragenrunitfull[gmod.numbpopl:] == 1).any():
raise Exception('')
if (gmodnext.paragenrunitfull[gmod.numbpopl:] == 0).any():
raise Exception('')
if not np.isfinite(gmodnext.paragenrunitfull).all():
raise Exception('')
gmodnext.paragenrscalfull = icdf_paragenrscalfull(gdat, strgmodl, gmodnext.paragenrunitfull, thisindxparagenrfullelem)
if gdat.booldiagmode:
if not np.isfinite(gmodnext.paragenrunitfull).all():
raise Exception('')
if np.amin(gmodnext.paragenrunitfull[gmod.numbpopl:]) < 0.:
raise Exception('')
if np.amax(gmodnext.paragenrunitfull[gmod.numbpopl:]) > 1.:
raise Exception('')
if not np.isfinite(gmodnext.paragenrscalfull).all():
raise Exception('')
if gdatmodi.this.indxproptype > 0:
gdatmodi.indxsamptran = []
if gdatmodi.this.indxproptype == 1:
gdatmodi.this.auxipara = np.random.rand(gmod.numbparagenrelemsing[gdatmodi.indxpopltran])
elif gdatmodi.this.indxproptype != 2:
gdatmodi.this.auxipara = np.empty(gmod.numbparagenrelemsing[gdatmodi.indxpopltran])
if gdatmodi.this.indxproptype == 1 or gdatmodi.this.indxproptype == 3:
# find an empty slot in the element list
for u in range(gmod.maxmpara.numbelem[gdatmodi.indxpopltran]):
if not u in gdatmodi.this.indxelemfull[gdatmodi.indxpopltran]:
break
gdatmodi.indxelemmodi = [u]
gdatmodi.indxelemfullmodi = [gmodthis.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]].astype(int)]
# sample indices to add the new element
gdatmodi.indxparagenrfullelemaddd = retr_indxparaelem(gmod, gdatmodi.indxpopltran, gdatmodi.indxelemmodi[0])
gdatmodi.indxsamptran.append(gdatmodi.indxparagenrfullelemaddd)
gmodnext.indxelemfull[gdatmodi.indxpopltran].append(gdatmodi.indxelemmodi[0])
if gdatmodi.this.indxproptype == 1:
# sample auxiliary variables
gmodnext.paragenrscalfull[gdatmodi.indxsamptran[0]] = gdatmodi.this.auxipara
# death
if gdatmodi.this.indxproptype == 2:
# occupied element index to be killed
if thisindxelem is None:
dethindxindxelem = np.random.choice(np.arange(gmodthis.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]], dtype=int))
else:
dethindxindxelem = thisindxelem
# element index to be killed
gdatmodi.indxelemmodi = []
gdatmodi.indxelemfullmodi = []
if gdat.typeverb > 1:
print('dethindxindxelem')
print(dethindxindxelem)
gdatmodi.indxelemmodi.append(gmodthis.indxelemfull[gdatmodi.indxpopltran][dethindxindxelem])
gdatmodi.indxelemfullmodi.append(dethindxindxelem)
# parameter indices to be killed
indxparagenrfullelemdeth = retr_indxparaelem(gmod, gdatmodi.indxpopltran, gdatmodi.indxelemmodi[0])
gdatmodi.indxsamptran.append(indxparagenrfullelemdeth)
gdatmodi.this.auxipara = gmodthis.paragenrscalfull[indxparagenrfullelemdeth]
if gdatmodi.this.indxproptype > 2:
gdatmodi.comppare = np.empty(gmod.numbparagenrelemsing[gdatmodi.indxpopltran])
gdatmodi.compfrst = np.empty(gmod.numbparagenrelemsing[gdatmodi.indxpopltran])
gdatmodi.compseco = np.empty(gmod.numbparagenrelemsing[gdatmodi.indxpopltran])
# split
if gdatmodi.this.indxproptype == 3:
# find the probability of splitting elements
gdatmodi.indxelemfullsplt = np.random.choice(np.arange(gmodthis.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]], dtype=int))
gdatmodi.indxelemsplt = gmodthis.indxelemfull[gdatmodi.indxpopltran][gdatmodi.indxelemfullsplt]
gdatmodi.indxelemfullmodi.insert(0, gdatmodi.indxelemfullsplt)
gdatmodi.indxelemmodi.insert(0, gdatmodi.indxelemsplt)
# sample indices for the first element
gdatmodi.indxparagenrfullelemfrst = retr_indxparaelem(gmod, l, gdatmodi.indxelemmodi[0])
gdatmodi.indxsamptran.insert(0, gdatmodi.indxparagenrfullelemfrst)
# sample indices for the second element
gdatmodi.indxsampseco = gdatmodi.indxparagenrfullelemaddd
# take the parent element parameters
for k, nameparagenrelem in enumerate(gmod.namepara.genrelem[gdatmodi.indxpopltran]):
gdatmodi.comppare[k] = np.copy(gmodthis.paragenrscalfull[thisindxparagenrfullelem[gdatmodi.indxpopltran][nameparagenrelem][gdatmodi.indxelemfullmodi[0]]])
# draw the auxiliary parameters
for g, nameparagenrelem in enumerate(gmod.namepara.genrelem[gdatmodi.indxpopltran]):
if gmod.boolcompposi[gdatmodi.indxpopltran][g]:
gdatmodi.this.auxipara[g] = np.random.randn() * gdat.radispmr
elif g == gmod.indxparagenrelemampl[gdatmodi.indxpopltran]:
gdatmodi.this.auxipara[g] = np.random.rand()
else:
gdatmodi.this.auxipara[g] = icdf_trap(gdat, strgmodl, np.random.rand(), gmodthis.paragenrscalfull, gmod.listscalparagenrelem[gdatmodi.indxpopltran][g], \
gmod.namepara.genrelem[gdatmodi.indxpopltran][g], l)
# determine the new parameters
if gmod.typeelem[gdatmodi.indxpopltran].startswith('lghtline'):
gdatmodi.compfrst[0] = gdatmodi.comppare[0] + (1. - gdatmodi.this.auxipara[1]) * gdatmodi.this.auxipara[0]
else:
gdatmodi.compfrst[0] = gdatmodi.comppare[0] + (1. - gdatmodi.this.auxipara[2]) * gdatmodi.this.auxipara[0]
gdatmodi.compfrst[1] = gdatmodi.comppare[1] + (1. - gdatmodi.this.auxipara[2]) * gdatmodi.this.auxipara[1]
gdatmodi.compfrst[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] = gdatmodi.this.auxipara[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] * \
gdatmodi.comppare[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]]
if gmod.typeelem[gdatmodi.indxpopltran].startswith('lghtline'):
gdatmodi.compseco[0] = gdatmodi.comppare[0] - gdatmodi.this.auxipara[1] * gdatmodi.this.auxipara[0]
else:
gdatmodi.compseco[0] = gdatmodi.comppare[0] - gdatmodi.this.auxipara[2] * gdatmodi.this.auxipara[0]
gdatmodi.compseco[1] = gdatmodi.comppare[1] - gdatmodi.this.auxipara[2] * gdatmodi.this.auxipara[1]
gdatmodi.compseco[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] = (1. - gdatmodi.this.auxipara[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]]) * \
gdatmodi.comppare[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]]
for g in range(gmod.numbparagenrelemsing[gdatmodi.indxpopltran]):
if not gmod.boolcompposi[gdatmodi.indxpopltran][g] and g != gmod.indxparagenrelemampl[gdatmodi.indxpopltran]:
gdatmodi.compfrst[g] = gdatmodi.comppare[g]
gdatmodi.compseco[g] = gdatmodi.this.auxipara[g]
# place the new parameters into the sample vector
gmodnext.paragenrscalfull[gdatmodi.indxsamptran[0]] = cdfn_trap(gdat, gdatmodi, strgmodl, gdatmodi.compfrst, gdatmodi.indxpopltran)
gmodnext.paragenrscalfull[gdatmodi.indxsamptran[0]] = gdatmodi.compfrst
gmodnext.paragenrscalfull[gdatmodi.indxsamptran[1]] = cdfn_trap(gdat, gdatmodi, strgmodl, gdatmodi.compseco, gdatmodi.indxpopltran)
gmodnext.paragenrscalfull[gdatmodi.indxsamptran[1]] = gdatmodi.compseco
# check for prior boundaries
if gmod.typeelem[gdatmodi.indxpopltran].startswith('lghtline'):
if np.fabs(gdatmodi.compfrst[0]) > gdat.maxmelin or np.fabs(gdatmodi.compseco[0]) > gdat.maxmelin:
gdatmodi.this.boolpropfilt = False
else:
if np.fabs(gdatmodi.compfrst[0]) > maxmlgal or np.fabs(gdatmodi.compseco[0]) > maxmlgal or \
np.fabs(gdatmodi.compfrst[1]) > maxmbgal or np.fabs(gdatmodi.compseco[1]) > maxmbgal:
gdatmodi.this.boolpropfilt = False
if gdatmodi.compfrst[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] < getattr(gmod.minmpara, gmod.nameparagenrelemampl[gdatmodi.indxpopltran]) or \
gdatmodi.compseco[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] < getattr(gmod.minmpara, gmod.nameparagenrelemampl[gdatmodi.indxpopltran]):
gdatmodi.this.boolpropfilt = False
if gdat.typeverb > 1:
if not gdatmodi.this.boolpropfilt:
print('Rejecting the proposal due to a split that falls out of the prior...')
if gdatmodi.this.indxproptype == 4:
# determine the index of the primary element to be merged (in the full element list)
gdatmodi.indxelemfullmergfrst = np.random.choice(np.arange(len(gmodthis.indxelemfull[gdatmodi.indxpopltran])))
## first element index to be merged
gdatmodi.mergindxelemfrst = gmodthis.indxelemfull[gdatmodi.indxpopltran][gdatmodi.indxelemfullmergfrst]
# find the probability of merging this element with the others
probmerg = retr_probmerg(gdat, gdatmodi, gmodthis.paragenrscalfull, thisindxparagenrfullelem, gdatmodi.indxpopltran, 'seco', typeelem=gmod.typeelem)
indxelemfulltemp = np.arange(len(gmodthis.indxelemfull[gdatmodi.indxpopltran]))
if gdat.booldiagmode:
if indxelemfulltemp.size < 2:
raise Exception('')
gdatmodi.indxelemfullmergseco = np.random.choice(np.setdiff1d(indxelemfulltemp, np.array([gdatmodi.indxelemfullmergfrst])), p=probmerg)
gdatmodi.indxelemfullmodi = np.sort(np.array([gdatmodi.indxelemfullmergfrst, gdatmodi.indxelemfullmergseco]))
# parameters of the first element to be merged
for k, nameparagenrelem in enumerate(gmod.namepara.genrelem[gdatmodi.indxpopltran]):
## first
gdatmodi.compfrst[k] = gmodthis.paragenrscalfull[thisindxparagenrfullelem[gdatmodi.indxpopltran][nameparagenrelem][gdatmodi.indxelemfullmodi[0]]]
# determine indices of the modified elements in the sample vector
## first element
# temp -- this would not work for multiple populations !
gdatmodi.indxparagenrfullelemfrst = retr_indxparaelem(gmod, l, gdatmodi.mergindxelemfrst)
gdatmodi.indxsamptran.append(gdatmodi.indxparagenrfullelemfrst)
## second element index to be merged
gdatmodi.mergindxelemseco = gmodthis.indxelemfull[gdatmodi.indxpopltran][gdatmodi.indxelemfullmergseco]
## second element
gdatmodi.indxparagenrfullelemseco = retr_indxparaelem(gmod, l, gdatmodi.mergindxelemseco)
gdatmodi.indxsamptran.append(gdatmodi.indxparagenrfullelemseco)
# parameters of the elements to be merged
for k, nameparagenrelem in enumerate(gmod.namepara.genrelem[gdatmodi.indxpopltran]):
## second
gdatmodi.compseco[k] = gmodthis.paragenrscalfull[thisindxparagenrfullelem[gdatmodi.indxpopltran][nameparagenrelem][gdatmodi.indxelemfullmodi[1]]]
# indices of the element to be merged
gdatmodi.indxelemmodi = [gdatmodi.mergindxelemfrst, gdatmodi.mergindxelemseco]
# auxiliary parameters
if gmod.typeelem[gdatmodi.indxpopltran].startswith('lghtline'):
gdatmodi.this.auxipara[0] = gdatmodi.compseco[0] - gdatmodi.compfrst[0]
else:
gdatmodi.this.auxipara[0] = gdatmodi.compseco[0] - gdatmodi.compfrst[0]
gdatmodi.this.auxipara[1] = gdatmodi.compseco[1] - gdatmodi.compfrst[1]
gdatmodi.this.auxipara[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] = gdatmodi.compfrst[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] / \
(gdatmodi.compfrst[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] + gdatmodi.compseco[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]])
for g, nameparagenrelem in enumerate(gmod.namepara.genrelem[gdatmodi.indxpopltran]):
if not gmod.boolcompposi[gdatmodi.indxpopltran][g] and g != gmod.indxparagenrelemampl[gdatmodi.indxpopltran]:
gdatmodi.this.auxipara[g] = gdatmodi.compseco[g]
# merged element
gdatmodi.comppare[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] = gdatmodi.compfrst[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] + \
gdatmodi.compseco[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]]
if gdatmodi.comppare[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]] > getattr(gdat, 'maxm' + gmod.nameparagenrelemampl[gdatmodi.indxpopltran]):
gdatmodi.this.boolpropfilt = False
if gdat.typeverb > 1:
print('Proposal rejected due to falling outside the prior.')
return
if gmod.typeelem[gdatmodi.indxpopltran].startswith('lghtline'):
gdatmodi.comppare[0] = gdatmodi.compfrst[0] + (1. - gdatmodi.this.auxipara[1]) * (gdatmodi.compseco[0] - gdatmodi.compfrst[0])
else:
gdatmodi.comppare[0] = gdatmodi.compfrst[0] + (1. - gdatmodi.this.auxipara[2]) * (gdatmodi.compseco[0] - gdatmodi.compfrst[0])
gdatmodi.comppare[1] = gdatmodi.compfrst[1] + (1. - gdatmodi.this.auxipara[2]) * (gdatmodi.compseco[1] - gdatmodi.compfrst[1])
for g, nameparagenrelem in enumerate(gmod.namepara.genrelem[gdatmodi.indxpopltran]):
if gmod.boolcompposi[gdatmodi.indxpopltran][g]:
gdatmodi.comppare[g] = gdatmodi.compfrst[g] + (1. - gdatmodi.this.auxipara[gmod.indxparagenrelemampl[gdatmodi.indxpopltran]]) * \
(gdatmodi.compseco[g] - gdatmodi.compfrst[g])
elif g == gmod.indxparagenrelemampl[gdatmodi.indxpopltran]:
gdatmodi.comppare[g] = gdatmodi.compfrst[g] + gdatmodi.compseco[g]
else:
gdatmodi.comppare[g] = gdatmodi.compfrst[g]
gmodnext.paragenrscalfull[gdatmodi.indxsamptran[0]] = cdfn_trap(gdat, gdatmodi, strgmodl, gdatmodi.comppare, gdatmodi.indxpopltran)
gmodnext.paragenrscalfull[gdatmodi.indxsamptran[0]] = gdatmodi.comppare
# calculate the proposed list of pairs
if gdat.typeverb > 1:
print('mergindxfrst: ', gdatmodi.mergindxelemfrst)
print('gdatmodi.indxelemfullmergfrst: ', gdatmodi.indxelemfullmergfrst)
print('mergindxseco: ', gdatmodi.mergindxelemseco)
print('gdatmodi.indxelemfullmergseco: ', gdatmodi.indxelemfullmergseco)
print('indxparagenrfullelemfrst: ', gdatmodi.indxparagenrfullelemfrst)
print('indxparagenrfullelemseco: ', gdatmodi.indxparagenrfullelemseco)
if gdat.typeverb > 1 and (gdatmodi.this.indxproptype == 3 or gdatmodi.this.boolpropfilt and gdatmodi.this.indxproptype == 4):
if gmod.typeelem[gdatmodi.indxpopltran].startswith('lghtline'):
print('elinfrst: ', gdatmodi.compfrst[0])
print('amplfrst: ', gdatmodi.compfrst[1])
print('elinseco: ', gdatmodi.compseco[0])
print('amplseco: ', gdatmodi.compseco[1])
print('elinpare: ', gdatmodi.comppare[0])
print('fluxpare: ', gdatmodi.comppare[1])
print('auxipara[0][0]: ', gdatmodi.this.auxipara[0])
print('auxipara[0][1]: ', gdatmodi.this.auxipara[1])
else:
print('lgalfrst: ', gdat.anglfact * gdatmodi.compfrst[0])
print('bgalfrst: ', gdat.anglfact * gdatmodi.compfrst[1])
print('amplfrst: ', gdatmodi.compfrst[2])
print('lgalseco: ', gdat.anglfact * gdatmodi.compseco[0])
print('bgalseco: ', gdat.anglfact * gdatmodi.compseco[1])
print('amplseco: ', gdatmodi.compseco[2])
print('lgalpare: ', gdat.anglfact * gdatmodi.comppare[0])
print('bgalpare: ', gdat.anglfact * gdatmodi.comppare[1])
print('fluxpare: ', gdatmodi.comppare[2])
print('auxipara[0][0]: ', gdat.anglfact * gdatmodi.this.auxipara[0])
print('auxipara[0][1]: ', gdat.anglfact * gdatmodi.this.auxipara[1])
print('auxipara[0][2]: ', gdatmodi.this.auxipara[2])
if gmod.numbparaelem > 0 and gdatmodi.this.indxproptype > 0 and gdatmodi.this.boolpropfilt:
# change the number of elements
if gdatmodi.this.indxproptype == 1 or gdatmodi.this.indxproptype == 3:
gmodnext.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]] = gmodthis.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]] + 1
if gdatmodi.this.indxproptype == 2 or gdatmodi.this.indxproptype == 4:
gmodnext.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]] = gmodthis.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]] - 1
gmodnext.paragenrunitfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]] = gmodnext.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]]
# remove the element from the occupied element list
if (gdatmodi.this.indxproptype == 2 or gdatmodi.this.indxproptype == 4):
for a, indxelem in enumerate(gdatmodi.indxelemmodi):
if a == 0 and gdatmodi.this.indxproptype == 2 or a == 1 and gdatmodi.this.indxproptype == 4:
gmodnext.indxelemfull[gdatmodi.indxpopltran].remove(indxelem)
if gdatmodi.this.indxproptype == 0:
gdatmodi.indxsampmodi = thisindxsampfull
else:
if gdatmodi.this.indxproptype == 1:
gdatmodi.indxsampmodi = np.concatenate((np.array([gmod.indxpara.numbelem[gdatmodi.indxpopltran]]), gdatmodi.indxsamptran[0]))
if gdatmodi.this.indxproptype == 2:
gdatmodi.indxsampmodi = [gmod.indxpara.numbelem[gdatmodi.indxpopltran]]
if gdatmodi.this.indxproptype == 3:
gdatmodi.indxsampmodi = np.concatenate((np.array([gmod.indxpara.numbelem[gdatmodi.indxpopltran]]), \
gdatmodi.indxsamptran[0], gdatmodi.indxsamptran[1]))
if gdatmodi.this.indxproptype == 4:
gdatmodi.indxsampmodi = np.concatenate((np.array([gmod.indxpara.numbelem[gdatmodi.indxpopltran]]), gdatmodi.indxsamptran[0]))
if gmod.numbparaelem > 0:
if gdatmodi.this.indxproptype == 0:
indxparagenrfullelem = thisindxparagenrfullelem
else:
indxparagenrfullelem = retr_indxparagenrfullelem(gdat, gmodnext.indxelemfull, strgmodl)
if gdat.typeverb > 1:
print('gdatmodi.indxsampmodi')
print(gdatmodi.indxsampmodi)
if gmod.numbparaelem > 0:
print('gmodthis.indxelemfull')
print(gmodthis.indxelemfull)
print('gmodthis.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]].astype(int)')
print(gmodthis.paragenrscalfull[gmod.indxpara.numbelem[gdatmodi.indxpopltran]].astype(int))
if gdatmodi.this.indxproptype > 0:
print('gdatmodi.indxelemmodi')
print(gdatmodi.indxelemmodi)
print('gdatmodi.indxelemfullmodi')
print(gdatmodi.indxelemfullmodi)
print('gdatmodi.this.boolpropfilt')
print(gdatmodi.this.boolpropfilt)
print('indxparagenrfullelem')
print(indxparagenrfullelem)
if gdatmodi.this.indxproptype == 1:
for g, nameparagenrelem in enumerate(gmod.namepara.genrelem[gdatmodi.indxpopltran]):
gmodnext.paragenrscalfull[gdatmodi.indxsamptran[0][g]] = icdf_trap(gdat, strgmodl, gdatmodi.this.auxipara[g], gmodthis.paragenrscalfull, \
gmod.listscalparagenrelem[gdatmodi.indxpopltran][g], \
gmod.namepara.genrelem[gdatmodi.indxpopltran][g], gdatmodi.indxpopltran)
if gdat.booldiagmode:
if gmod.numbparaelem > 0:
for l in gmod.indxpopl:
if gmodthis.paragenrunitfull[gmod.indxpara.numbelem[l]] != round(gmodthis.paragenrunitfull[gmod.indxpara.numbelem[l]]):
print('l')
print(l)
print('gmod.indxpara.numbelem')
print(gmod.indxpara.numbelem)
print('gmodthis.paragenrunitfull')
print(gmodthis.paragenrunitfull)
raise Exception('')
if gmodthis.paragenrscalfull[gmod.indxpara.numbelem[l]] != round(gmodthis.paragenrscalfull[gmod.indxpara.numbelem[l]]):
raise Exception('')
if gmodnext.paragenrunitfull[gmod.indxpara.numbelem[l]] != round(gmodnext.paragenrunitfull[gmod.indxpara.numbelem[l]]):
raise Exception('')
if gmodnext.paragenrscalfull[gmod.indxpara.numbelem[l]] != round(gmodnext.paragenrscalfull[gmod.indxpara.numbelem[l]]):
raise Exception('')
if strgmodl == 'fitt':
diffparagenrscalfull = abs(gmodnext.paragenrscalfull - gmodthis.paragenrscalfull)
#size = np.where(((gmodthis.paragenrscalfull == 0.) & (diffparagenrscalfull > 0.)) | ((gmodthis.paragenrscalfull != 0.) & (diffparagenrscalfull / gmodthis.paragenrscalfull > 0)))[0].size
size = np.where(diffparagenrscalfull != 0.)[0].size
if gdatmodi.this.indxproptype == 1:
if size - 1 != gmod.numbparagenrelemsing[gdatmodi.indxpopltran]:
raise Exception('')
def calc_probprop(gdat, gdatmodi):
gmod = gdat.fitt
# calculate the factor to multiply the acceptance rate, i.e.,
## probability of the auxiliary parameters,
if gdatmodi.this.indxproptype == 0:
gdatmodi.this.lpau = 0.
elif gdatmodi.this.indxproptype == 1 or gdatmodi.this.indxproptype == 2:
gdatmodi.this.lpau = gdatmodi.next.lpritotl - gdatmodi.this.lpritotl
lpautemp = 0.5 * gdat.priofactdoff * gmod.numbparagenrelemsing[gdatmodi.indxpopltran]
if gdatmodi.this.indxproptype == 1:
gdatmodi.this.lpau += lpautemp
if gdatmodi.this.indxproptype == 2:
gdatmodi.this.lpau -= lpautemp
elif gdatmodi.this.indxproptype == 3 or gdatmodi.this.indxproptype == 4:
gdatmodi.this.lpau = 0.
dictelemtemp = [dict()]
for g, nameparagenrelem in enumerate(gmod.namepara.genrelem[gdatmodi.indxpopltran]):
if gmod.gmod.boolcompposi[gdatmodi.indxpopltran][g]:
gdatmodi.this.lpau += -0.5 * np.log(2. * np.pi * gdat.radispmr**2) - 0.5 * (gdatmodi.this.auxipara[g] / gdat.radispmr)**2
elif g != gmod.indxparagenrelemampl[gdatmodi.indxpopltran]:
dictelemtemp[0][nameparagenrelem] = gdatmodi.this.auxipara[g]
gdatmodi.this.lpau += retr_lprielem(gdat, 'fitt', gdatmodi.indxpopltran, g, \
gmod.namepara.genrelem[gdatmodi.indxpopltran][g], gmod.listscalparagenrelem[gdatmodi.indxpopltran][g], \
gdatmodi.this.paragenrscalfull, dictelemtemp, [1])
if gdatmodi.this.indxproptype == 4:
gdatmodi.this.lpau *= -1.
if gdatmodi.this.indxproptype > 2 and gdatmodi.this.boolpropfilt:
## the ratio of the probability of the reverse and forward proposals, and
if gdatmodi.this.indxproptype == 3:
gdatmodi.this.probmergtotl = retr_probmerg(gdat, gdatmodi, gdatmodi.next.paragenrscalfull, gdatmodi.next.indxparagenrfullelem, gdatmodi.indxpopltran, 'pair', \
typeelem=gmod.typeelem)
gdatmodi.this.ltrp = np.log(gdatmodi.this.numbelem[gdatmodi.indxpopltran] + 1) + np.log(gdatmodi.this.probmergtotl)
else:
gdatmodi.this.probmergtotl = retr_probmerg(gdat, gdatmodi, gdatmodi.this.paragenrscalfull, gdatmodi.this.indxparagenrfullelem, gdatmodi.indxpopltran, 'pair', \
typeelem=gmod.typeelem)
gdatmodi.this.ltrp = -np.log(gdatmodi.this.numbelem[gdatmodi.indxpopltran]) - np.log(gdatmodi.this.probmergtotl)
## Jacobian
if gmod.typeelem[gdatmodi.indxpopltran].startswith('lghtline'):
gdatmodi.this.ljcb = np.log(gdatmodi.comppare[1])
else:
gdatmodi.this.ljcb = np.log(gdatmodi.comppare[2])
if gdatmodi.this.indxproptype == 4:
gdatmodi.this.ljcb *= -1.
else:
gdatmodi.this.ljcb = 0.
gdatmodi.this.ltrp = 0.
for l in gmod.indxpopl:
if gdatmodi.this.indxproptype > 0:
setattr(gdatmodi, 'auxiparapop%d' % l, gdatmodi.this.auxipara)
def retr_indxparagenrfullelem(gdat, indxelemfull, strgmodl):
gmod = getattr(gdat, strgmodl)
## element parameters
if gmod.numbparaelem > 0:
indxparagenrfullelem = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
indxparagenrfulltemp = gmod.indxparagenrfulleleminit + gmod.numbparagenrelemcuml[l] + np.array(indxelemfull[l], dtype=int) * gmod.numbparagenrelemsing[l]
cntr = tdpy.cntr()
indxparagenrfullelem[l] = dict()
for nameparagenrelem in gmod.namepara.genrelem[l]:
indxparagenrfullelem[l][nameparagenrelem] = indxparagenrfulltemp + cntr.incr()
indxparagenrfullelem[l]['full'] = np.repeat(indxparagenrfulltemp, gmod.numbparagenrelemsing[l]) + np.tile(gmod.indxparagenrelemsing[l], len(indxelemfull[l]))
if gdat.booldiagmode:
for l in gmod.indxpopl:
if len(indxparagenrfullelem[l]['full']) > 0:
if np.amax(indxparagenrfullelem[l]['full']) > gmod.numbparagenrelem[l] + gmod.numbparagenrbase:
print('strgmodl')
print(strgmodl)
print('strgstat')
print(strgstat)
print('gmod.numbparagenrbase')
print(gmod.numbparagenrbase)
print('gmod.numbparagenrelem[l]')
print(gmod.numbparagenrelem[l])
print('indxparagenrfullelem[l][full]')
summgene(indxparagenrfullelem[l]['full'])
print('gdat.fitt.minmpara.numbelempop0')
print(gdat.fitt.minmpara.numbelempop0)
print('gdat.fitt.maxmpara.numbelempop0')
print(gdat.fitt.maxmpara.numbelempop0)
raise Exception('Element parameter indices are bad.')
else:
indxparagenrfullelem = None
return indxparagenrfullelem
def retr_weigmergodim(gdat, elin, elinothr):
weigmerg = np.exp(-0.5 * ((elin - elinothr) / gdat.radispmr)**2)
return weigmerg
def retr_weigmergtdim(gdat, lgal, lgalothr, bgal, bgalothr):
weigmerg = np.exp(-0.5 * (((lgal - lgalothr) / gdat.radispmr)**2 + ((bgal - bgalothr) / gdat.radispmr)**2))
return weigmerg
def retr_probmerg(gdat, gdatmodi, paragenrscalfull, indxparagenrfullelem, indxpopltran, strgtype, typeelem=None):
# calculate the weights
if strgtype == 'seco':
numb = 1
if strgtype == 'pair':
numb = 2
listweigmerg = []
for a in range(numb):
if gmod.typeelem[indxpopltran].startswith('lghtline'):
elintotl = paragenrscalfull[indxparagenrfullelem['elin'][indxpopltran]]
elin = elintotl[gdatmodi.indxelemfullmodi[0]]
elinothr = np.concatenate((elintotl[:gdatmodi.indxelemfullmodi[0]], elintotl[gdatmodi.indxelemfullmodi[0]+1:]))
weigmerg = retr_weigmergodim(gdat, elin, elinothr)
else:
lgaltotl = paragenrscalfull[indxparagenrfullelem['lgal'][indxpopltran]]
bgaltotl = paragenrscalfull[indxparagenrfullelem['bgal'][indxpopltran]]
lgal = lgaltotl[gdatmodi.indxelemfullmodi[0]]
bgal = bgaltotl[gdatmodi.indxelemfullmodi[0]]
lgalothr = np.concatenate((lgaltotl[:gdatmodi.indxelemfullmodi[0]], lgaltotl[gdatmodi.indxelemfullmodi[0]+1:]))
bgalothr = np.concatenate((bgaltotl[:gdatmodi.indxelemfullmodi[0]], bgaltotl[gdatmodi.indxelemfullmodi[0]+1:]))
weigmerg = retr_weigmergtdim(gdat, lgal, lgalothr, bgal, bgalothr)
listweigmerg.append(weigmerg)
# determine the probability of merging the second element given the first element
if strgtype == 'seco':
probmerg = listweigmerg[0] / np.sum(listweigmerg[0])
# determine the probability of merging the pair
if strgtype == 'pair':
if gmod.typeelem[indxpopltran].startswith('lghtline'):
weigpair = retr_weigmergtdim(gdat, elin, elintotl[gdatmodi.indxelemfullmodi[1]])
else:
weigpair = retr_weigmergtdim(gdat, lgal, lgaltotl[gdatmodi.indxelemfullmodi[1]], bgal, bgaltotl[gdatmodi.indxelemfullmodi[1]])
probmerg = weigpair / np.sum(listweigmerg[0]) + weigpair / np.sum(listweigmerg[1])
if gdat.booldiagmode:
if not np.isfinite(probmerg).all():
raise Exception('Merge probability is infinite.')
return probmerg
def retr_indxparaelem(gmod, l, u):
indxsamppnts = gmod.indxparagenrfulleleminit + gmod.numbparagenrelemcuml[l] + u * gmod.numbparagenrelemsing[l] + gmod.indxparagenrelemsing[l]
return indxsamppnts
def gang_detr():
gang, aang, lgal, bgal = sympy.symbols('gang aang lgal bgal')
AB = sympy.matrices.Matrix([[a1*b1,a1*b2,a1*b3],[a2*b1,a2*b2,a2*b3],[a3*b1,a3*b2,a3*b3]])
def retr_psfn(gdat, psfp, indxenertemp, thisangl, typemodlpsfn, strgmodl):
gmod = getattr(gdat, strgmodl)
indxpsfpinit = gmod.numbpsfptotl * (indxenertemp[:, None] + gdat.numbener * gdat.indxevtt[None, :])
if gdat.typeexpr == 'ferm':
scalangl = 2. * np.arcsin(np.sqrt(2. - 2. * np.cos(thisangl)) / 2.)[None, :, None] / gdat.fermscalfact[:, None, :]
scalanglnorm = 2. * np.arcsin(np.sqrt(2. - 2. * np.cos(gdat.binspara.angl)) / 2.)[None, :, None] / gdat.fermscalfact[:, None, :]
else:
scalangl = thisangl[None, :, None]
if typemodlpsfn == 'singgaus':
sigc = psfp[indxpsfpinit]
sigc = sigc[:, None, :]
psfn = retr_singgaus(scalangl, sigc)
elif typemodlpsfn == 'singking':
sigc = psfp[indxpsfpinit]
gamc = psfp[indxpsfpinit+1]
sigc = sigc[:, None, :]
gamc = gamc[:, None, :]
psfn = retr_singking(scalangl, sigc, gamc)
elif typemodlpsfn == 'doubking':
sigc = psfp[indxpsfpinit]
gamc = psfp[indxpsfpinit+1]
sigt = psfp[indxpsfpinit+2]
gamt = psfp[indxpsfpinit+3]
frac = psfp[indxpsfpinit+4]
sigc = sigc[:, None, :]
gamc = gamc[:, None, :]
sigt = sigt[:, None, :]
gamt = gamt[:, None, :]
frac = frac[:, None, :]
psfn = retr_doubking(scalangl, frac, sigc, gamc, sigt, gamt)
if gdat.typeexpr == 'ferm':
psfnnorm = retr_doubking(scalanglnorm, frac, sigc, gamc, sigt, gamt)
# normalize the PSF
if gdat.typeexpr == 'ferm':
fact = 2. * np.pi * np.trapz(psfnnorm * np.sin(gdat.binspara.angl[None, :, None]), gdat.binspara.angl, axis=1)[:, None, :]
psfn /= fact
return psfn
def retr_unit(lgal, bgal):
xdat = np.cos(bgal) * np.cos(lgal)
ydat = -np.cos(bgal) * np.sin(lgal)
zaxi = np.sin(bgal)
return xdat, ydat, zaxi
def retr_psec(gdat, conv):
# temp
conv = conv.reshape((gdat.numbsidecart, gdat.numbsidecart))
psec = (abs(scipy.fftpack.fft2(conv))**2)[:gdat.numbsidecarthalf, :gdat.numbsidecarthalf] * 1e-3
psec = psec.flatten()
return psec
def retr_psecodim(gdat, psec):
psec = psec.reshape((gdat.numbsidecarthalf, gdat.numbsidecarthalf))
psecodim = np.zeros(gdat.numbsidecarthalf)
for k in gdat.indxmpolodim:
indxmpol = np.where((gdat.meanpara.mpol > gdat.binspara.mpolodim[k]) & (gdat.meanpara.mpol < gdat.binspara.mpolodim[k+1]))
psecodim[k] = np.mean(psec[indxmpol])
psecodim *= gdat.meanpara.mpolodim**2
return psecodim
def retr_eerrnorm(minmvarb, maxmvarb, meanvarb, stdvvarb):
cdfnminm = 0.5 * (sp.special.erf((minmvarb - meanvarb) / stdvvarb / np.sqrt(2.)) + 1.)
cdfnmaxm = 0.5 * (sp.special.erf((maxmvarb - meanvarb) / stdvvarb / np.sqrt(2.)) + 1.)
cdfndiff = cdfnmaxm - cdfnminm
return cdfnminm, cdfndiff
def retr_condcatl(gdat):
# setup
## number of stacked samples
numbstks = 0
indxtupl = []
indxstks = []
indxstksparagenrscalfull = []
for n in gdat.indxsamptotl:
indxstks.append([])
indxstkssamptemp = []
for l in gmod.indxpopl:
indxstks[n].append([])
for k in range(len(gdat.listpostindxelemfull[n][l])):
indxstks[n][l].append(numbstks)
indxstkssamptemp.append(numbstks)
indxtupl.append([n, l, k])
numbstks += 1
indxstkssamp.append(np.array(indxstkssamptemp))
if gdat.typeverb > 1:
print('indxstks')
print(indxstks)
print('indxtupl')
print(indxtupl)
print('indxstkssamp')
print(indxstksparagenrscalfull)
print('numbstks')
print(numbstks)
cntr = 0
arrystks = np.zeros((numbstks, gmod.numbparagenrelemtotl))
for n in gdat.indxsamptotl:
indxparagenrfullelem = retr_indxparagenrfullelem(gdat, gdat.listpostindxelemfull[n], 'fitt')
for l in gmod.indxpopl:
for k in np.arange(len(gdat.listpostindxelemfull[n][l])):
for m, nameparagenrelem in enumerate(gmod.namepara.genrelem[l]):
arrystks[indxstks[n][l][k], m] = gdat.listpostparagenrscalfull[n, gmodstat.indxparagenrfullelem[l][nameparagenrelem][k]]
if gdat.typeverb > 0:
print('Constructing the distance matrix for %d stacked samples...' % arrystks.shape[0])
timeinit = gdat.functime()
gdat.distthrs = np.empty(gmod.numbparagenrelemtotl)
for k, nameparagenrelem in enumerate(gmod.namepara.elem):
# temp
l = 0
gdat.distthrs[k] = gdat.stdp[getattr(gdat, 'indxstdppop%d' % l + nameparagenrelem)]
# construct lists of samples for each proposal type
listdisttemp = [[] for k in range(gmod.numbparagenrelemtotl)]
indxstksrows = [[] for k in range(gmod.numbparagenrelemtotl)]
indxstkscols = [[] for k in range(gmod.numbparagenrelemtotl)]
thisperc = 0
cntr = 0
for k in gmod.indxparagenrelemtotl:
for n in range(numbstks):
dist = np.fabs(arrystks[n, k] - arrystks[:, k])
indxstks = np.where(dist < gdat.distthrs[k])[0]
if indxstks.size > 0:
for j in indxstks:
cntr += 1
listdisttemp[k].append(dist[j])
indxstksrows[k].append(n)
indxstkscols[k].append(j)
nextperc = np.floor(100. * float(k * numbstks + n) / numbstks / gmod.numbparagenrelemtotl)
if nextperc > thisperc:
thisperc = nextperc
if cntr > 1e6:
break
listdisttemp[k] = np.array(listdisttemp[k])
indxstksrows[k] = np.array(indxstksrows[k])
indxstkscols[k] = np.array(indxstkscols[k])
if cntr > 1e6:
break
listdist = [[] for k in range(gmod.numbparagenrelemtotl)]
for k, nameparagenrelem in enumerate(gmod.namepara.elem):
listdist[k] = scipy.sparse.csr_matrix((listdisttemp[k], (indxstksrows[k], indxstkscols[k])), shape=(numbstks, numbstks))
listindxstkspair = []
indxstksleft = []
if gdat.typeverb > 0:
timefinl = gdat.functime()
indxstksleft = range(numbstks)
# list of sample lists of the labeled element
indxstksassc = []
cntr = 0
gdat.prvlthrs = 0.05
while len(indxstksleft) > 0:
# count number of associations
numbdist = np.zeros(numbstks, dtype=int) - 1
for p in range(len(indxstksleft)):
indxindx = np.where((listdist[0][indxstksleft[p], :].tonp.array().flatten() * 2. * gdat.maxmlgal < gdat.anglassc) & \
(listdist[1][indxstksleft[p], :].tonp.array().flatten() * 2. * gdat.maxmbgal < gdat.anglassc))[0]
numbdist[indxstksleft[p]] = indxindx.size
prvlmaxmesti = np.amax(numbdist) / float(gdat.numbsamptotl)
if prvlmaxmesti < gdat.prvlthrs:
break
# determine the element with the highest number of neighbors
indxstkscntr = np.argmax(numbdist)
indxsamptotlcntr = indxtupl[indxstkscntr][0]
indxpoplcntr = indxtupl[indxstkscntr][1]
indxelemcntr = indxtupl[indxstkscntr][2]
# add the central element sample
indxstksassc.append([])
indxstksassc[cntr].append(indxstkscntr)
indxstksleft.remove(indxstkscntr)
if gdat.typeverb > 1:
print('Match step %d' % cntr)
print('numbdist')
print(numbdist)
print('indxstkscntr')
print(indxstkscntr)
print('indxstksleft')
print(indxstksleft)
# add the associated element samples
if len(indxstksleft) > 0:
for n in gdat.indxsamptotl:
indxstkstemp = np.intersect1d(np.array(indxstksleft), indxstksparagenrscalfull[n])
if n == indxsamptotlcntr:
continue
if indxstkstemp.size > 0:
totl = np.zeros_like(indxstkstemp)
for k in gmod.indxparagenrelemtotl:
temp = listdist[k][indxstkscntr, indxstkstemp].tonp.array()[0]
totl = totl + temp**2
indxleft = np.argsort(totl)[0]
indxstksthis = indxstkstemp[indxleft]
thisbool = True
for k in gmod.indxparagenrelemtotl:
if listdist[k][indxstkscntr, indxstksthis] > gdat.distthrs[k]:
thisbool = False
if thisbool:
indxstksassc[cntr].append(indxstksthis)
indxstksleft.remove(indxstksthis)
# temp
#if gdat.makeplot:
# gdatmodi = tdpy.gdatstrt()
# gdatmodi.this.indxelemfull = deepcopy(listindxelemfull[n])
# for r in range(len(indxstksassc)):
# calc_poststkscond(gdat, indxstksassc)
# gdatmodi.this.indxelemfull = [[] for l in gmod.indxpopl]
# for indxstkstemp in indxstksleft:
# indxsamptotlcntr = indxtupl[indxstkstemp][0]
# indxpoplcntr = indxtupl[indxstkstemp][1]
# indxelemcntr = indxtupl[indxstkstemp][2]
# gdatmodi.this.paragenrscalfull = gdat.listparagenrscalfull[indxsamptotlcntr, :]
# gdatmodi.this.indxelemfull[].append()
# plot_genemaps(gdat, gdatmodi, 'this', 'cntpdata', strgpdfn, indxenerplot=0, indxevttplot=0, cond=True)
cntr += 1
gdat.dictglob['poststkscond'] = []
gdat.dictglob['liststkscond'] = []
# for each condensed element
for r in range(len(indxstksassc)):
gdat.dictglob['liststkscond'].append([])
gdat.dictglob['liststkscond'][r] = {}
gdat.dictglob['poststkscond'].append([])
gdat.dictglob['poststkscond'][r] = {}
for strgfeat in gmod.namepara.genrelem:
gdat.dictglob['liststkscond'][r][strgfeat] = []
# for each associated sample associated with the central stacked sample
for k in range(len(indxstksassc[r])):
indxsamptotlcntr = indxtupl[indxstksassc[r][k]][0]
indxpoplcntr = indxtupl[indxstksassc[r][k]][1]
indxelemcntr = indxtupl[indxstksassc[r][k]][2]
for strgfeat in gmod.namepara.genrelem:
temp = getattr(gdat, 'list' + strgfeat)
if temp[indxsamptotlcntr][indxpoplcntr].size > 0:
temp = temp[indxsamptotlcntr][indxpoplcntr][..., indxelemcntr]
gdat.dictglob['liststkscond'][r][strgfeat].append(temp)
for r in range(len(gdat.dictglob['liststkscond'])):
for strgfeat in gmod.namepara.genrelem:
arry = np.stack(gdat.dictglob['liststkscond'][r][strgfeat], axis=0)
gdat.dictglob['poststkscond'][r][strgfeat] = np.zeros(([3] + list(arry.shape[1:])))
gdat.dictglob['poststkscond'][r][strgfeat][0, ...] = median(arry, axis=0)
gdat.dictglob['poststkscond'][r][strgfeat][1, ...] = percennp.tile(arry, 16., axis=0)
gdat.dictglob['poststkscond'][r][strgfeat][2, ...] = percennp.tile(arry, 84., axis=0)
gdat.numbstkscond = len(gdat.dictglob['liststkscond'])
gdat.indxstkscond = np.arange(gdat.numbstkscond)
gdat.prvl = np.empty(gdat.numbstkscond)
for r in gdat.indxstkscond:
gdat.prvl[r] = len(gdat.dictglob['liststkscond'][r]['deltllik'])
gdat.prvl /= gdat.numbsamptotl
gdat.minmprvl = 0.
gdat.maxmprvl = 1.
retr_axis(gdat, 'prvl')
gdat.histprvl = np.histogram(gdat.prvl, bins=gdat.binspara.prvl)[0]
if gdat.makeplot:
pathcond = getattr(gdat, 'path' + strgpdfn + 'finlcond')
for k, nameparagenrelem in enumerate(gmod.namepara.elem):
path = pathcond + 'histdist' + nameparagenrelem
listtemp = np.copy(listdist[k].tonp.array()).flatten()
listtemp = listtemp[np.where(listtemp != 1e20)[0]]
tdpy.mcmc.plot_hist(path, listtemp, r'$\Delta \tilde{' + getattr(gmod.lablrootpara, nameparagenrelem) + '}$')
path = pathcond + 'histprvl'
tdpy.mcmc.plot_hist(path, gdat.prvl, r'$p$')
gdat.prvlthrs = 0.1
gdat.indxprvlhigh = np.where(gdat.prvl > gdat.prvlthrs)[0]
gdat.numbprvlhigh = gdat.indxprvlhigh.size
def retr_conv(gdat, defl):
defl = defl.reshape((gdat.numbsidecart, gdat.numbsidecart, 2))
# temp
conv = abs(np.gradient(defl[:, :, 0], gdat.sizepixl, axis=0) + np.gradient(defl[:, :, 1], gdat.sizepixl, axis=1)) / 2.
conv = conv.flatten()
return conv
def retr_invm(gdat, defl):
# temp
defl = defl.reshape((gdat.numbsidecart, gdat.numbsidecart, 2))
invm = (1. - np.gradient(defl[:, :, 0], gdat.sizepixl, axis=0)) * (1. - np.gradient(defl[:, :, 1], gdat.sizepixl, axis=1)) - \
np.gradient(defl[:, :, 0], gdat.sizepixl, axis=1) * np.gradient(defl[:, :, 1], gdat.sizepixl, axis=0)
invm = invm.flatten()
return invm
def setp_indxswepsave(gdat):
gdat.indxswep = np.arange(gdat.numbswep)
gdat.boolsave = np.zeros(gdat.numbswep, dtype=bool)
gdat.indxswepsave = np.arange(gdat.numbburn, gdat.numbburn + gdat.numbsamp * gdat.factthin, gdat.factthin)
gdat.boolsave[gdat.indxswepsave] = True
gdat.indxsampsave = np.zeros(gdat.numbswep, dtype=int) - 1
gdat.indxsampsave[gdat.indxswepsave] = np.arange(gdat.numbsamp)
def retr_cntspnts(gdat, listposi, spec):
cnts = np.zeros((gdat.numbener, spec.shape[1]))
if gdat.boolbinsspat:
lgal = listposi[0]
bgal = listposi[1]
indxpixlpnts = retr_indxpixl(gdat, bgal, lgal)
else:
elin = listposi[0]
indxpixlpnts = np.zeros_like(elin, dtype=int)
for k in range(spec.shape[1]):
cnts[:, k] += spec[:, k] * gdat.expototl[:, indxpixlpnts[k]]
if gdat.enerdiff:
cnts *= gdat.deltener[:, None]
cnts = np.sum(cnts, axis=0)
return cnts
def retr_mdencrit(gdat, adissour, adishost, adishostsour):
mdencrit = gdat.factnewtlght / 4. / np.pi * adissour / adishostsour / adishost
return mdencrit
def retr_massfrombein(gdat, adissour, adishost, adishostsour):
mdencrit = retr_mdencrit(gdat, adissour, adishost, adishostsour)
massfrombein = np.pi * adishost**2 * mdencrit
return massfrombein
def retr_factmcutfromdefs(gdat, adissour, adishost, adishostsour, asca, acut):
mdencrit = retr_mdencrit(gdat, adissour, adishost, adishostsour)
fracacutasca = acut / asca
factmcutfromdefs = np.pi * adishost**2 * mdencrit * asca * retr_mcutfrommscl(fracacutasca)
return factmcutfromdefs
def retr_mcut(gdat, defs, asca, acut, adishost, mdencrit):
mscl = defs * np.pi * adishost**2 * mdencrit * asca
fracacutasca = acut / asca
mcut = mscl * retr_mcutfrommscl(fracacutasca)
return mcut
def retr_mcutfrommscl(fracacutasca):
mcut = fracacutasca**2 / (fracacutasca**2 + 1.)**2 * ((fracacutasca**2 - 1.) * np.log(fracacutasca) + fracacutasca * np.pi - (fracacutasca**2 + 1.))
return mcut
def retr_negalogt(varb):
negalogt = sign(varb) * np.log10(np.fabs(varb))
return negalogt
def retr_gradmaps(gdat, maps):
# temp -- this does not work with vanishing exposure
maps = maps.reshape((gdat.numbsidecart, gdat.numbsidecart))
grad = np.dstack((np.gradient(maps, gdat.sizepixl, axis=0), np.gradient(maps, gdat.sizepixl, axis=1))).reshape((gdat.numbsidecart, gdat.numbsidecart, 2))
grad = grad.reshape((gdat.numbpixlcart, 2))
return grad
def retr_spatmean(gdat, inpt, boolcntp=False):
listspatmean = [[] for b in gdat.indxspatmean]
listspatstdv = [[] for b in gdat.indxspatmean]
for b, namespatmean in enumerate(gdat.listnamespatmean):
if boolcntp:
cntp = inpt[gdat.listindxcubespatmean[b]]
else:
cntp = inpt[gdat.listindxcubespatmean[b]] * gdat.expo[gdat.listindxcubespatmean[b]] * gdat.apix
if gdat.enerdiff:
cntp *= gdat.deltener[:, None, None]
spatmean = np.mean(np.sum(cntp, 2), axis=1) / gdat.apix
spatstdv = np.sqrt(np.sum(cntp, axis=(1, 2))) / gdat.numbdata / gdat.apix
if gdat.boolcorrexpo:
spatmean /= gdat.expototlmean
spatstdv /= gdat.expototlmean
if gdat.enerdiff:
spatmean /= gdat.deltener
spatstdv /= gdat.deltener
listspatmean[b] = spatmean
listspatstdv[b] = spatstdv
return listspatmean, listspatstdv
def retr_rele(gdat, maps, lgal, bgal, defs, asca, acut, indxpixlelem, absv=True, cntpmodl=None):
grad = retr_gradmaps(gdat, maps)
defl = retr_defl(gdat, indxpixlelem, lgal, bgal, defs, asca=asca, acut=acut)
prod = grad * defl
if cntpmodl is not None:
prod /= cntpmodl[:, None]
dotstemp = np.sum(prod, 1)
if absv:
dotstemp = np.fabs(dotstemp)
else:
dotstemp = dotstemp
dots = np.mean(dotstemp)
return dots
def retr_fromgdat(gdat, gdatmodi, strgstat, strgmodl, strgvarb, strgpdfn, strgmome='pmea', indxvarb=None, indxlist=None):
if strgvarb.startswith('cntpdata'):
varb = getattr(gdat, strgvarb)
elif strgvarb.startswith('histcntpdata'):
varb = getattr(gdat, strgvarb)
else:
if strgmodl == 'true':
gmod = getattr(gdat, strgmodl)
gmodstat = getattr(gmod, strgstat)
varb = getattr(gmodstat, strgvarb)
if strgmodl == 'fitt':
if strgstat == 'this':
if strgmome == 'errr':
varb = getattr(gdatmodi, strgstat + 'errr' + strgvarb)
else:
varb = getattr(gdatmodi, strgstat + strgvarb)
if strgstat == 'pdfn':
varb = getattr(gdat, strgmome + strgpdfn + strgvarb)
if indxlist is not None:
varb = varb[indxlist]
if indxvarb is not None:
if strgmome == 'errr':
varb = varb[[slice(None)] + indxvarb]
else:
varb = varb[indxvarb]
return np.copy(varb)
def setp_indxpara(gdat, typesetp, strgmodl='fitt'):
print('setp_indxpara(): Building parameter indices for model %s with type %s...' % (strgmodl, typesetp))
gmod = getattr(gdat, strgmodl)
if typesetp == 'init':
if strgmodl == 'fitt':
gmod.lablmodl = 'Model'
if strgmodl == 'true':
gmod.lablmodl = 'True'
# transdimensional element populations
gmod.numbpopl = len(gmod.typeelem)
gmod.indxpopl = np.arange(gmod.numbpopl)
if gdat.typeexpr != 'user':
# background component
gmod.numbback = 0
gmod.indxback = []
for c in range(len(gmod.typeback)):
if isinstance(gmod.typeback[c], str):
if gmod.typeback[c].startswith('bfunfour') or gmod.typeback[c].startswith('bfunwfou'):
namebfun = gmod.typeback[c][:8]
ordrexpa = int(gmod.typeback[c][8:])
numbexpa = 4 * ordrexpa**2
indxexpa = np.arange(numbexpa)
del gmod.typeback[c]
for k in indxexpa:
gmod.typeback.insert(c+k, namebfun + '%04d' % k)
gmod.numbback = len(gmod.typeback)
gmod.indxback = np.arange(gmod.numbback)
gmod.numbbacktotl = np.sum(gmod.numbback)
gmod.indxbacktotl = np.arange(gmod.numbbacktotl)
# galaxy components
gmod.indxsersfgrd = np.arange(gmod.numbsersfgrd)
# name of the generative element parameter used for the amplitude
gmod.nameparagenrelemampl = [[] for l in gmod.indxpopl]
gmod.indxparagenrelemampl = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.typeelem[l] == 'lghtpntspuls':
gmod.nameparagenrelemampl[l] = 'per0'
gmod.indxparagenrelemampl[l] = 2
elif gmod.typeelem[l] == 'lghtpntsagnntrue':
gmod.nameparagenrelemampl[l] = 'lum0'
gmod.indxparagenrelemampl[l] = 2
elif gmod.typeelem[l].startswith('lghtline'):
gmod.nameparagenrelemampl[l] = 'flux'
gmod.indxparagenrelemampl[l] = 1
elif gmod.typeelem[l].startswith('lghtpnts'):
gmod.nameparagenrelemampl[l] = 'flux'
gmod.indxparagenrelemampl[l] = 2
elif gmod.typeelem[l].startswith('lghtgausbgrd'):
gmod.nameparagenrelemampl[l] = 'flux'
gmod.indxparagenrelemampl[l] = 2
if gmod.typeelem[l] == 'lens':
gmod.nameparagenrelemampl[l] = 'defs'
gmod.indxparagenrelemampl[l] = 2
if gmod.typeelem[l].startswith('clus'):
gmod.nameparagenrelemampl[l] = 'nobj'
gmod.indxparagenrelemampl[l] = 2
if gmod.typeelem[l] == 'lens':
gmod.nameparagenrelemampl[l] = 'defs'
if gmod.typeelem[l] == 'clus':
gmod.nameparagenrelemampl[l] = 'nobj'
if len(gmod.nameparagenrelemampl[l]) == 0:
raise Exception('Amplitude feature undefined.')
for featpara in gdat.listfeatpara:
for strggrop in gdat.liststrggroppara:
setattr(gmod, 'list' + featpara + 'para' + strggrop, [])
if typesetp == 'finl':
# number of elements in the current state of the true model
if strgmodl == 'true':
gmod.numbelem = np.zeros(gmod.numbpopl)
for l in gmod.indxpopl:
gmod.numbelem[l] += getattr(gmod.maxmpara, 'numbelempop%d' % l)
gmod.numbelemtotl = np.sum(gmod.numbelem)
# element setup
## flag to calculate the kernel approximation errors
boolcalcerrr = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.typeelemspateval[l] == 'locl' and gdat.numbpixlfull < 1e5:
# temp
boolcalcerrr[l] = False
else:
boolcalcerrr[l] = False
setp_varb(gdat, 'boolcalcerrr', valu=boolcalcerrr, strgmodl=strgmodl)
# maximum number of elements for each population
gmod.maxmpara.numbelem = np.zeros(gmod.numbpopl, dtype=int)
for l in gmod.indxpopl:
gmod.maxmpara.numbelem[l] = getattr(gmod.maxmpara, 'numbelempop%d' % l)
# maximum number of elements summed over all populations
gmod.maxmpara.numbelemtotl = np.sum(gmod.maxmpara.numbelem)
## sorting feature
nameparaelemsort = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
# feature to be used to sort elements
if gmod.typeelem[l].startswith('lght'):
nameparaelemsort[l] = 'flux'
if gmod.typeelem[l] == 'lens':
nameparaelemsort[l] = 'defs'
if gmod.typeelem[l].startswith('clus'):
nameparaelemsort[l] = 'nobj'
## label extensions
gmod.lablelemextn = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gdat.numbgrid > 1:
if gmod.typeelem[l] == 'lghtpnts':
gmod.lablelemextn[l] = r'\rm{fps}'
if gmod.typeelem[l] == 'lghtgausbgrd':
gmod.lablelemextn[l] = r'\rm{bgs}'
else:
if gmod.typeelem[l].startswith('lghtpntspuls'):
gmod.lablelemextn[l] = r'\rm{pul}'
if gmod.typeelem[l].startswith('lghtpntsagnn'):
gmod.lablelemextn[l] = r'\rm{agn}'
elif gmod.typeelem[l] == 'lghtpnts':
gmod.lablelemextn[l] = r'\rm{pts}'
if gmod.typeelem[l] == 'lens':
gmod.lablelemextn[l] = r'\rm{sub}'
if gmod.typeelem[l].startswith('clus'):
gmod.lablelemextn[l] = r'\rm{cls}'
if gmod.typeelem[l].startswith('lghtline'):
gmod.lablelemextn[l] = r'\rm{lin}'
gmod.indxpoplgrid = [[] for y in gdat.indxgrid]
for y in gdat.indxgrid:
for indx, typeelemtemp in enumerate(gmod.typeelem):
# foreground grid (image plane) -- the one np.where the data is measured
if y == 0:
if typeelemtemp.startswith('lght') and not typeelemtemp.endswith('bgrd') or typeelemtemp.startswith('clus'):
gmod.indxpoplgrid[y].append(indx)
# foreground mass grid
if y == 1:
if typeelemtemp.startswith('lens'):
gmod.indxpoplgrid[y].append(indx)
# background grid (source plane)
if y == 2:
if typeelemtemp.endswith('bgrd'):
gmod.indxpoplgrid[y].append(indx)
indxgridpopl = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
for y in gdat.indxgrid:
if l in gmod.indxpoplgrid[y]:
indxgridpopl[l] = y
calcelemsbrt = False
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lghtpnts'):
calcelemsbrt = True
if 'lghtgausbgrd' in gmod.typeelem:
calcelemsbrtbgrd = True
else:
calcelemsbrtbgrd = False
if gmod.boollenssubh:
calcelemdefl = True
else:
calcelemdefl = False
## element Boolean flags
gmod.boolelemlght = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lght'):
gmod.boolelemlght[l] = True
else:
gmod.boolelemlght[l] = False
gmod.boolelemlghtanyy = True in gmod.boolelemlght
gmod.boolelemlens = False
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lens'):
gmod.boolelemlens = True
gmod.boolelemsbrtdfnc = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.maxmpara.numbelem[l] > 0 and (gmod.typeelem[l].startswith('lght') and not gmod.typeelem[l].endswith('bgrd') or gmod.typeelem[l].startswith('clus')):
gmod.boolelemsbrtdfnc[l] = True
else:
gmod.boolelemsbrtdfnc[l] = False
gmod.boolelemsbrtdfncanyy = True in gmod.boolelemsbrtdfnc
gmod.boolelemdeflsubh = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.typeelem[l] == 'lens':
gmod.boolelemdeflsubh[l] = True
else:
gmod.boolelemdeflsubh[l] = False
gmod.boolelemdeflsubhanyy = True in gmod.boolelemdeflsubh
gmod.boolelemsbrtextsbgrd = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lght') and gmod.typeelem[l].endswith('bgrd'):
gmod.boolelemsbrtextsbgrd[l] = True
else:
gmod.boolelemsbrtextsbgrd[l] = False
gmod.boolelemsbrtextsbgrdanyy = True in gmod.boolelemsbrtextsbgrd
if gmod.boolelemsbrtextsbgrdanyy:
gmod.indxpopllens = 1
else:
gmod.indxpopllens = 0
gmod.boolelemsbrtpnts = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lght') and gmod.typeelem[l] != 'lghtline' or gmod.typeelem[l] == 'clus':
gmod.boolelemsbrtpnts[l] = True
else:
gmod.boolelemsbrtpnts[l] = False
gmod.boolelemsbrtpntsanyy = True in gmod.boolelemsbrtpnts
# temp -- because there is currently no extended source
gmod.boolelemsbrt = gmod.boolelemsbrtdfnc
gmod.boolelempsfn = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lghtpnts') or gmod.typeelem[l] == 'clus':
gmod.boolelempsfn[l] = True
else:
gmod.boolelempsfn[l] = False
gmod.boolelempsfnanyy = True in gmod.boolelempsfn
spectype = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.boolelemlght[l]:
spectype[l] = 'powr'
else:
spectype[l] = 'none'
setp_varb(gdat, 'spectype', valu=spectype, strgmodl=strgmodl)
minmgwdt = 2. * gdat.sizepixl
maxmgwdt = gdat.maxmgangdata / 4.
setp_varb(gdat, 'gwdt', minm=minmgwdt, maxm=maxmgwdt, strgmodl=strgmodl)
setp_varb(gdat, 'aerr', minm=-100, maxm=100, strgmodl=strgmodl, popl='full')
if gmod.boolelemlghtanyy:
# flux
if gdat.typeexpr == 'ferm':
minmflux = 1e-9
maxmflux = 1e-6
if gdat.typeexpr == 'tess':
minmflux = 1.
maxmflux = 1e3
if gdat.typeexpr == 'chan':
if gdat.anlytype == 'spec':
minmflux = 1e4
maxmflux = 1e7
else:
minmflux = 3e-9
maxmflux = 1e-6
if gdat.typeexpr == 'gene':
minmflux = 0.1
maxmflux = 100.
if gdat.typeexpr == 'hubb':
minmflux = 1e-20
maxmflux = 1e-17
if gdat.typeexpr == 'fire':
minmflux = 1e-20
maxmflux = 1e-17
setp_varb(gdat, 'flux', limt=[minmflux, maxmflux], strgmodl=strgmodl)
if gdat.typeexpr == 'ferm':
setp_varb(gdat, 'brekprioflux', limt=[3e-9, 1e-6], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'sloplowrprioflux', limt=[0.5, 3.], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'slopupprprioflux', limt=[0.5, 3.], popl=l, strgmodl=strgmodl)
if gdat.boolbinsener:
### spectral parameters
if gdat.typeexpr == 'ferm':
sind = [1., 3.]
minmsind = 1.
maxmsind = 3.
if gdat.typeexpr == 'chan':
minmsind = 0.4
maxmsind = 2.4
sind = [0.4, 2.4]
if gdat.typeexpr == 'hubb':
minmsind = 0.5
maxmsind = 2.5
sind = [0.4, 2.4]
if gdat.typeexpr != 'fire':
setp_varb(gdat, 'sind', limt=[minmsind, maxmsind], strgmodl=strgmodl)
setp_varb(gdat, 'curv', limt=[-1., 1.], strgmodl=strgmodl)
setp_varb(gdat, 'expc', limt=[0.1, 10.], strgmodl=strgmodl)
setp_varb(gdat, 'sinddistmean', limt=sind, popl='full', strgmodl=strgmodl)
#### standard deviations should not be too small
setp_varb(gdat, 'sinddiststdv', limt=[0.3, 2.], popl='full', strgmodl=strgmodl)
setp_varb(gdat, 'curvdistmean', limt=[-1., 1.], popl='full', strgmodl=strgmodl)
setp_varb(gdat, 'curvdiststdv', limt=[0.1, 1.], popl='full', strgmodl=strgmodl)
setp_varb(gdat, 'expcdistmean', limt=[1., 8.], popl='full', strgmodl=strgmodl)
setp_varb(gdat, 'expcdiststdv', limt=[0.01 * gdat.maxmener, gdat.maxmener], popl='full', strgmodl=strgmodl)
for i in gdat.indxenerinde:
setp_varb(gdat, 'sindcolr0001', limt=[-2., 6.], strgmodl=strgmodl)
setp_varb(gdat, 'sindcolr0002', limt=[0., 8.], strgmodl=strgmodl)
setp_varb(gdat, 'sindcolr%04d' % i, limt=[-5., 10.], strgmodl=strgmodl)
for l in gmod.indxpopl:
if gmod.typeelem[l] == 'lghtpntspuls':
setp_varb(gdat, 'gang', limt=[1e-1 * gdat.sizepixl, gdat.maxmgangdata], strgmodl=strgmodl)
setp_varb(gdat, 'geff', limt=[0., 0.4], strgmodl=strgmodl)
setp_varb(gdat, 'dglc', limt=[10., 3e3], strgmodl=strgmodl)
setp_varb(gdat, 'phii', limt=[0., 2. * np.pi], strgmodl=strgmodl)
setp_varb(gdat, 'thet', limt=[0., np.pi], strgmodl=strgmodl)
setp_varb(gdat, 'per0distmean', limt=[5e-4, 1e1], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'magfdistmean', limt=[1e7, 1e16], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'per0diststdv', limt=[1e-2, 1.], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'magfdiststdv', limt=[1e-2, 1.], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'gangslop', limt=[0.5, 4.], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'dglcslop', limt=[0.5, 2.], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'spatdistcons', limt=[1e-4, 1e-2], popl='full')
setp_varb(gdat, 'bgaldistscal', limt=[0.5 / gdat.anglfact, 5. / gdat.anglfact], popl='full', strgmodl=strgmodl)
if gmod.typeelem[l] == 'lghtpntsagnntrue':
setp_varb(gdat, 'dlos', limt=[1e7, 1e9], strgmodl=strgmodl)
setp_varb(gdat, 'dlosslop', limt=[-0.5, -3.], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'lum0', limt=[1e43, 1e46], strgmodl=strgmodl)
setp_varb(gdat, 'lum0distbrek', limt=[1e42, 1e46], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'lum0sloplowr', limt=[0.5, 3.], popl=l, strgmodl=strgmodl)
setp_varb(gdat, 'lum0slopuppr', limt=[0.5, 3.], popl=l, strgmodl=strgmodl)
# construct background surface brightness templates from the user input
gmod.sbrtbacknorm = [[] for c in gmod.indxback]
gmod.boolunifback = np.ones(gmod.numbback, dtype=bool)
for c in gmod.indxback:
gmod.sbrtbacknorm[c] = np.empty((gdat.numbenerfull, gdat.numbpixlfull, gdat.numbevttfull))
if gmod.typeback[c] == 'data':
gmod.sbrtbacknorm[c] = np.copy(gdat.sbrtdata)
gmod.sbrtbacknorm[c][np.where(gmod.sbrtbacknorm[c] == 0.)] = 1e-100
elif isinstance(gmod.typeback[c], float):
gmod.sbrtbacknorm[c] = np.zeros((gdat.numbenerfull, gdat.numbpixlfull, gdat.numbevttfull)) + gmod.typeback[c]
elif isinstance(gmod.typeback[c], list) and isinstance(gmod.typeback[c], float):
gmod.sbrtbacknorm[c] = retr_spec(gdat, np.array([gmod.typeback[c]]), sind=np.array([gmod.typeback[c]]))[:, 0, None, None]
elif isinstance(gmod.typeback[c], np.ndarray) and gmod.typeback[c].ndim == 1:
gmod.sbrtbacknorm[c] = np.zeros((gdat.numbenerfull, gdat.numbpixlfull, gdat.numbevttfull)) + gmod.typeback[c][:, None, None]
elif gmod.typeback[c].startswith('bfunfour') or gmod.typeback[c].startswith('bfunwfou'):
indxexpatemp = int(gmod.typeback[c][8:])
indxterm = indxexpatemp // ordrexpa**2
indxexpaxdat = (indxexpatemp % ordrexpa**2) // ordrexpa + 1
indxexpaydat = (indxexpatemp % ordrexpa**2) % ordrexpa + 1
if namebfun == 'bfunfour':
ampl = 1.
func = gdat.meanpara.bgalcart
if namebfun == 'bfunwfou':
functemp = np.exp(-0.5 * (gdat.meanpara.bgalcart / (1. / gdat.anglfact))**2)
ampl = np.sqrt(functemp)
func = functemp
argslgal = 2. * np.pi * indxexpaxdat * gdat.meanpara.lgalcart / gdat.maxmgangdata
argsbgal = 2. * np.pi * indxexpaydat * func / gdat.maxmgangdata
if indxterm == 0:
termfrst = np.sin(argslgal)
termseco = ampl * np.sin(argsbgal)
if indxterm == 1:
termfrst = np.sin(argslgal)
termseco = ampl * np.cos(argsbgal)
if indxterm == 2:
termfrst = np.cos(argslgal)
termseco = ampl * np.sin(argsbgal)
if indxterm == 3:
termfrst = np.cos(argslgal)
termseco = ampl * np.cos(argsbgal)
gmod.sbrtbacknorm[c] = (termfrst[None, :] * termseco[:, None]).flatten()[None, :, None] * \
np.ones((gdat.numbenerfull, gdat.numbpixlfull, gdat.numbevttfull))
else:
path = gdat.pathinpt + gmod.typeback[c]
gmod.sbrtbacknorm[c] = astropy.io.fits.getdata(path)
if gdat.typepixl == 'cart':
if not gdat.boolforccart:
if gmod.sbrtbacknorm[c].shape[2] != gdat.numbsidecart:
raise Exception('Provided background template must have the chosen image dimensions.')
gmod.sbrtbacknorm[c] = gmod.sbrtbacknorm[c].reshape((gmod.sbrtbacknorm[c].shape[0], -1, gmod.sbrtbacknorm[c].shape[-1]))
if gdat.typepixl == 'cart' and gdat.boolforccart:
sbrtbacknormtemp = np.empty((gdat.numbenerfull, gdat.numbpixlfull, gdat.numbevttfull))
for i in gdat.indxenerfull:
for m in gdat.indxevttfull:
sbrtbacknormtemp[i, :, m] = tdpy.retr_cart(gmod.sbrtbacknorm[c][i, :, m], \
numbsidelgal=gdat.numbsidecart, numbsidebgal=gdat.numbsidecart, \
minmlgal=gdat.anglfact*gdat.minmlgaldata, maxmlgal=gdat.anglfact*gdat.maxmlgaldata, \
minmbgal=gdat.anglfact*gdat.minmbgaldata, maxmbgal=gdat.anglfact*gdat.maxmbgaldata).flatten()
gmod.sbrtbacknorm[c] = sbrtbacknormtemp
# determine spatially uniform background templates
for i in gdat.indxenerfull:
for m in gdat.indxevttfull:
if np.std(gmod.sbrtbacknorm[c][i, :, m]) > 1e-6:
gmod.boolunifback[c] = False
boolzero = True
gmod.boolbfun = False
for c in gmod.indxback:
if np.amin(gmod.sbrtbacknorm[c]) < 0. and isinstance(gmod.typeback[c], str) and not gmod.typeback[c].startswith('bfun'):
booltemp = False
raise Exception('Background templates must be positive-definite every where.')
if not np.isfinite(gmod.sbrtbacknorm[c]).all():
raise Exception('Background template is not finite.')
if np.amin(gmod.sbrtbacknorm[c]) > 0. or gmod.typeback[c] == 'data':
boolzero = False
if isinstance(gmod.typeback[c], str) and gmod.typeback[c].startswith('bfun'):
gmod.boolbfun = True
if boolzero and not gmod.boolbfun:
raise Exception('At least one background template must be positive everynp.where.')
# temp -- does not take into account dark hosts
gmod.boolhost = gmod.typeemishost != 'none'
# type of PSF evaluation
if gmod.maxmpara.numbelemtotl > 0 and gmod.boolelempsfnanyy:
if gmod.typeemishost != 'none' or not gmod.boolunifback.all():
# the background is not convolved by a kernel and point sources exist
typeevalpsfn = 'full'
else:
# the background is not convolved by a kernel and point sources exist
typeevalpsfn = 'kern'
else:
if gmod.typeemishost != 'none' or not gmod.boolunifback.all():
# the background is convolved by a kernel, no point source exists
typeevalpsfn = 'conv'
else:
# the background is not convolved by a kernel, no point source exists
typeevalpsfn = 'none'
setp_varb(gdat, 'typeevalpsfn', valu=typeevalpsfn, strgmodl=strgmodl)
if gdat.typeverb > 1:
print('gmod.typeevalpsfn')
print(gmod.typeevalpsfn)
gmod.boolapplpsfn = gmod.typeevalpsfn != 'none'
### PSF model
if gmod.typeevalpsfn != 'none':
if gmod.typemodlpsfn == 'singgaus':
numbpsfpform = 1
elif gmod.typemodlpsfn == 'singking':
numbpsfpform = 2
elif gmod.typemodlpsfn == 'doubgaus':
numbpsfpform = 3
elif gmod.typemodlpsfn == 'gausking':
numbpsfpform = 4
elif gmod.typemodlpsfn == 'doubking':
numbpsfpform = 5
gmod.numbpsfptotl = numbpsfpform
if gdat.boolpriopsfninfo:
for i in gdat.indxener:
for m in gdat.indxevtt:
meansigc = gmod.psfpexpr[i * gmod.numbpsfptotl + m * gmod.numbpsfptotl * gdat.numbener]
stdvsigc = meansigc * 0.1
setp_varb(gdat, 'sigcen%02devt%d' % (i, m), mean=meansigc, stdv=stdvsigc, lablroot='$\sigma$', scal='gaus', \
strgmodl=strgmodl)
if gmod.typemodlpsfn == 'doubking' or gmod.typemodlpsfn == 'singking':
meangamc = gmod.psfpexpr[i * numbpsfpform + m * numbpsfpform * gdat.numbener + 1]
stdvgamc = meangamc * 0.1
setp_varb(gdat, 'gamcen%02devt%d' % (i, m), mean=meangamc, stdv=stdvgamc, strgmodl=strgmodl)
if gmod.typemodlpsfn == 'doubking':
meansigt = gmod.psfpexpr[i * numbpsfpform + m * numbpsfpform * gdat.numbener + 2]
stdvsigt = meansigt * 0.1
setp_varb(gdat, 'sigten%02devt%d' % (i, m), mean=meansigt, stdv=stdvsigt, strgmodl=strgmodl)
meangamt = gmod.psfpexpr[i * numbpsfpform + m * numbpsfpform * gdat.numbener + 3]
stdvgamt = meangamt * 0.1
setp_varb(gdat, 'gamten%02devt%d' % (i, m), mean=meangamt, stdv=stdvgamt, strgmodl=strgmodl)
meanpsff = gmod.psfpexpr[i * numbpsfpform + m * numbpsfpform * gdat.numbener + 4]
stdvpsff = meanpsff * 0.1
setp_varb(gdat, 'psffen%02devt%d' % (i, m), mean=meanpsff, stdv=stdvpsff, strgmodl=strgmodl)
else:
if gdat.typeexpr == 'gene':
minmsigm = 0.01 / gdat.anglfact
maxmsigm = 0.1 / gdat.anglfact
if gdat.typeexpr == 'ferm':
minmsigm = 0.1
maxmsigm = 10.
if gdat.typeexpr == 'hubb':
minmsigm = 0.01 / gdat.anglfact
maxmsigm = 0.1 / gdat.anglfact
if gdat.typeexpr == 'chan':
minmsigm = 0.1 / gdat.anglfact
maxmsigm = 2. / gdat.anglfact
minmgamm = 1.5
maxmgamm = 20.
setp_varb(gdat, 'sigc', minm=minmsigm, maxm=maxmsigm, lablroot='$\sigma_c$', ener='full', evtt='full', strgmodl=strgmodl)
setp_varb(gdat, 'sigt', minm=minmsigm, maxm=maxmsigm, ener='full', evtt='full', strgmodl=strgmodl)
setp_varb(gdat, 'gamc', minm=minmgamm, maxm=maxmgamm, ener='full', evtt='full', strgmodl=strgmodl)
setp_varb(gdat, 'gamt', minm=minmgamm, maxm=maxmgamm, ener='full', evtt='full', strgmodl=strgmodl)
setp_varb(gdat, 'psff', minm=0., maxm=1., ener='full', evtt='full', strgmodl=strgmodl)
# background
## number of background parameters
numbbacp = 0
for c in gmod.indxback:
if gmod.boolspecback[c]:
numbbacp += 1
else:
numbbacp += gdat.numbener
## background parameter indices
gmod.indxbackbacp = np.zeros(numbbacp, dtype=int)
indxenerbacp = np.zeros(numbbacp, dtype=int)
cntr = 0
for c in gmod.indxback:
if gmod.boolspecback[c]:
gmod.indxbackbacp[cntr] = c
cntr += 1
else:
for i in gdat.indxener:
indxenerbacp[cntr] = i
gmod.indxbackbacp[cntr] = c
cntr += 1
# indices of background parameters for each background component
gmod.indxbacpback = [[] for c in gmod.indxback]
for c in gmod.indxback:
gmod.indxbacpback[c] = np.where((gmod.indxbackbacp == c))[0]
# list of names of diffuse components
gmod.listnamediff = []
for c in gmod.indxback:
gmod.listnamediff += ['back%04d' % c]
if gmod.typeemishost != 'none':
for e in gmod.indxsersfgrd:
gmod.listnamediff += ['hostisf%d' % e]
if gmod.boollens:
gmod.listnamediff += ['lens']
# list of names of emission components
listnameecom = deepcopy(gmod.listnamediff)
for l in gmod.indxpopl:
if gmod.boolelemsbrt[l]:
if strgmodl == 'true' and gmod.numbelem[l] > 0 or strgmodl == 'fitt' and gmod.maxmpara.numbelem[l] > 0:
if not 'dfnc' in listnameecom:
listnameecom += ['dfnc']
if not 'dfncsubt' in listnameecom:
listnameecom += ['dfncsubt']
gmod.listnameecomtotl = listnameecom + ['modl']
for c in gmod.indxback:
setp_varb(gdat, 'cntpback%04d' % c, lablroot='$C_{%d}$' % c, minm=1., maxm=100., scal='logt', strgmodl=strgmodl)
gmod.listnamegcom = deepcopy(gmod.listnameecomtotl)
if gmod.boollens:
gmod.listnamegcom += ['bgrd']
if gmod.numbparaelem > 0 and gmod.boolelemsbrtextsbgrdanyy:
gmod.listnamegcom += ['bgrdgalx', 'bgrdexts']
numbdiff = len(gmod.listnamediff)
convdiff = np.zeros(numbdiff, dtype=bool)
for k, namediff in enumerate(gmod.listnamediff):
if not (gdat.boolthindata or gmod.typeevalpsfn == 'none' or gmod.typeevalpsfn == 'kern'):
if namediff.startswith('back'):
indx = int(namediff[-4:])
convdiff[k] = not gmod.boolunifback[indx]
else:
convdiff[k] = True
# element parameters that correlate with the statistical significance of the element
gmod.namepara.elemsign = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lght'):
gmod.namepara.elemsign[l] = 'flux'
if gmod.typeelem[l] == 'lens':
gmod.namepara.elemsign[l] = 'defs'
if gmod.typeelem[l].startswith('clus'):
gmod.namepara.elemsign[l] = 'nobj'
if gdat.typeverb > 0:
if strgmodl == 'true':
strgtemp = 'true'
if strgmodl == 'fitt':
strgtemp = 'fitting'
print('Building elements for the %s model...' % strgtemp)
# define the names and scalings of element parameters
gmod.namepara.genrelem = [[] for l in gmod.indxpopl]
gmod.listscalparagenrelem = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lghtline'):
gmod.namepara.genrelem[l] = ['elin']
gmod.listscalparagenrelem[l] = ['logt']
elif gmod.typespatdist[l] == 'diskscal':
gmod.namepara.genrelem[l] = ['lgal', 'bgal']
gmod.listscalparagenrelem[l] = ['self', 'dexp']
elif gmod.typespatdist[l] == 'gangexpo':
gmod.namepara.genrelem[l] = ['gang', 'aang']
gmod.listscalparagenrelem[l] = ['expo', 'self']
elif gmod.typespatdist[l] == 'glc3':
gmod.namepara.genrelem[l] = ['dglc', 'thet', 'phii']
gmod.listscalparagenrelem[l] = ['powr', 'self', 'self']
else:
gmod.namepara.genrelem[l] = ['lgal', 'bgal']
gmod.listscalparagenrelem[l] = ['self', 'self']
# amplitude
if gmod.typeelem[l] == 'lghtpntsagnntrue':
gmod.namepara.genrelem[l] += ['lum0']
gmod.listscalparagenrelem[l] += ['dpowslopbrek']
elif gmod.typeelem[l] == 'lghtpntspuls':
gmod.namepara.genrelem[l] += ['per0']
gmod.listscalparagenrelem[l] += ['lnormeanstdv']
elif gmod.typeelem[l].startswith('lght'):
gmod.namepara.genrelem[l] += ['flux']
gmod.listscalparagenrelem[l] += [gmod.typeprioflux[l]]
elif gmod.typeelem[l] == 'lens':
gmod.namepara.genrelem[l] += ['defs']
gmod.listscalparagenrelem[l] += ['powr']
elif gmod.typeelem[l].startswith('clus'):
gmod.namepara.genrelem[l] += ['nobj']
gmod.listscalparagenrelem[l] += ['powr']
# shape
if gmod.typeelem[l] == 'lghtgausbgrd' or gmod.typeelem[l] == 'clusvari':
gmod.namepara.genrelem[l] += ['gwdt']
gmod.listscalparagenrelem[l] += ['powr']
if gmod.typeelem[l] == 'lghtlinevoig':
gmod.namepara.genrelem[l] += ['sigm']
gmod.listscalparagenrelem[l] += ['logt']
gmod.namepara.genrelem[l] += ['gamm']
gmod.listscalparagenrelem[l] += ['logt']
# others
if gmod.typeelem[l] == 'lghtpntspuls':
gmod.namepara.genrelem[l] += ['magf']
gmod.listscalparagenrelem[l] += ['lnormeanstdv']
gmod.namepara.genrelem[l] += ['geff']
gmod.listscalparagenrelem[l] += ['self']
elif gmod.typeelem[l] == 'lghtpntsagnntrue':
gmod.namepara.genrelem[l] += ['dlos']
gmod.listscalparagenrelem[l] += ['powr']
if gdat.numbener > 1 and gmod.typeelem[l].startswith('lghtpnts'):
if gmod.spectype[l] == 'colr':
for i in gdat.indxener:
if i == 0:
continue
gmod.namepara.genrelem[l] += ['sindcolr%04d' % i]
gmod.listscalparagenrelem[l] += ['self']
else:
gmod.namepara.genrelem[l] += ['sind']
gmod.listscalparagenrelem[l] += ['self']
if gmod.spectype[l] == 'curv':
gmod.namepara.genrelem[l] += ['curv']
gmod.listscalparagenrelem[l] += ['self']
if gmod.spectype[l] == 'expc':
gmod.namepara.genrelem[l] += ['expc']
gmod.listscalparagenrelem[l] += ['self']
if gmod.typeelem[l] == 'lens':
if gdat.variasca:
gmod.namepara.genrelem[l] += ['asca']
gmod.listscalparagenrelem[l] += ['self']
if gdat.variacut:
gmod.namepara.genrelem[l] += ['acut']
gmod.listscalparagenrelem[l] += ['self']
# names of element parameters for each scaling
gmod.namepara.genrelemscal = [{} for l in gmod.indxpopl]
for l in gmod.indxpopl:
for scaltype in gdat.listscaltype:
gmod.namepara.genrelemscal[l][scaltype] = []
for k, nameparagenrelem in enumerate(gmod.namepara.genrelem[l]):
if scaltype == gmod.listscalparagenrelem[l][k]:
gmod.namepara.genrelemscal[l][scaltype].append(nameparagenrelem)
# variables for which whose marginal distribution and pair-correlations will be plotted
gmod.namepara.derielemodim = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
gmod.namepara.derielemodim[l] = deepcopy(gmod.namepara.genrelem[l])
gmod.namepara.derielemodim[l] += ['deltllik']
if gdat.boolbinsspat:
if not 'lgal' in gmod.namepara.derielemodim[l]:
gmod.namepara.derielemodim[l] += ['lgal']
if not 'bgal' in gmod.namepara.derielemodim[l]:
gmod.namepara.derielemodim[l] += ['bgal']
if not 'gang' in gmod.namepara.derielemodim[l]:
gmod.namepara.derielemodim[l] += ['gang']
if not 'aang' in gmod.namepara.derielemodim[l]:
gmod.namepara.derielemodim[l] += ['aang']
if gmod.typeelem[l].startswith('lght'):
gmod.namepara.derielemodim[l] += ['cnts']
if gdat.typeexpr == 'ferm':
gmod.namepara.derielemodim[l] + ['sbrt0018']
if gmod.typeelem[l] == 'lghtpntsagnntrue':
gmod.namepara.derielemodim[l] += ['reds']
gmod.namepara.derielemodim[l] += ['lumi']
gmod.namepara.derielemodim[l] += ['flux']
if gmod.typeelem[l] == 'lghtpntspuls':
gmod.namepara.derielemodim[l] += ['lumi']
gmod.namepara.derielemodim[l] += ['flux']
gmod.namepara.derielemodim[l] += ['mass']
gmod.namepara.derielemodim[l] += ['dlos']
if gmod.typeelem[l] == 'lens':
gmod.namepara.derielemodim[l] += ['mcut', 'diss', 'rele', 'reln', 'relk', 'relf', 'relm', 'reld', 'relc']
#for k in range(len(gmod.namepara.derielemodim[l])):
# gmod.namepara.derielemodim[l][k] += 'pop%d' % l
# check later
# temp
#if strgmodl == 'fitt':
# for q in gdat.indxrefr:
# if gmod.nameparagenrelemampl[l] in gdat.refr.namepara.elem[q]:
# gmod.namepara.derielemodim[l].append('aerr' + gdat.listnamerefr[q])
if gdat.typeverb > 1:
print('gmod.namepara.derielemodim')
print(gmod.namepara.derielemodim)
# derived element parameters
gmod.namepara.derielem = gmod.namepara.derielemodim[:]
if gdat.typeverb > 1:
print('gmod.namepara.derielem')
print(gmod.namepara.derielem)
# derived parameters
gmod.listnameparaderitotl = [temptemp for temp in gmod.namepara.derielem for temptemp in temp]
#gmod.listnameparaderitotl += gmod.namepara.scal
for namediff in gmod.listnamediff:
gmod.listnameparaderitotl += ['cntp' + namediff]
if gdat.typeverb > 1:
print('gmod.listnameparaderitotl')
print(gmod.listnameparaderitotl)
if strgmodl == 'fitt':
# add reference element parameters that are not available in the fitting model
gdat.refr.namepara.elemonly = [[[] for l in gmod.indxpopl] for q in gdat.indxrefr]
gmod.namepara.extrelem = [[] for l in gmod.indxpopl]
for q in gdat.indxrefr:
if gdat.refr.numbelem[q] == 0:
continue
for name in gdat.refr.namepara.elem[q]:
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lght') and (name == 'defs' or name == 'acut' or name == 'asca' or name == 'mass'):
continue
if gmod.typeelem[l] == ('lens') and (name == 'cnts' or name == 'flux' or name == 'spec' or name == 'sind'):
continue
if not name in gmod.namepara.derielemodim[l]:
nametotl = name + gdat.listnamerefr[q]
if name == 'etag':
continue
gmod.namepara.derielemodim[l].append(nametotl)
if gdat.refr.numbelem[q] == 0:
continue
gdat.refr.namepara.elemonly[q][l].append(name)
if not nametotl in gmod.namepara.extrelem[l]:
gmod.namepara.extrelem[l].append(nametotl)
#if name == 'reds':
# for nametemp in ['lumi', 'dlos']:
# nametemptemp = nametemp + gdat.listnamerefr[q]
# if not nametemptemp in gmod.namepara.extrelem[l]:
# gmod.namepara.derielemodim[l].append(nametemp + gdat.listnamerefr[q])
# gmod.namepara.extrelem[l].append(nametemptemp)
if gdat.typeverb > 1:
print('gdat.refr.namepara.elemonly')
print(gdat.refr.namepara.elemonly)
if gdat.typeexpr == 'chan' and gdat.typedata == 'inpt':
for l in gmod.indxpopl:
if gmod.typeelem[l] == 'lghtpnts':
gmod.namepara.extrelem[l].append('lumiwo08')
gmod.namepara.derielemodim[l].append('lumiwo08')
if gdat.typeverb > 1:
print('gmod.namepara.extrelem')
print(gmod.namepara.extrelem)
# defaults
gmod.liststrgpdfnmodu = [[] for l in gmod.indxpopl]
gmod.namepara.genrelemmodu = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lght'):
if gdat.typeexpr == 'ferm' and gdat.lgalcntr == 0.:
if l == 1:
gmod.liststrgpdfnmodu[l] += ['tmplnfwp']
gmod.namepara.genrelemmodu[l] += ['lgalbgal']
if l == 2:
gmod.liststrgpdfnmodu[l] += ['tmplnfwp']
gmod.namepara.genrelemmodu[l] += ['lgalbgal']
gmod.namepara.elem = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
for liststrg in [gmod.namepara.genrelem[l], gmod.namepara.derielemodim[l]]:
for strgthis in liststrg:
if not strgthis in gmod.namepara.elem[l]:
gmod.namepara.elem[l].append(strgthis)
# temp
for l in gmod.indxpopl:
if gmod.typeelem[l].startswith('lghtline'):
gmod.namepara.genrelem[l] += ['spec']
if gmod.typeelem[l].startswith('lght'):
gmod.namepara.genrelem[l] += ['spec', 'specplot']
if gmod.typeelem[l] == 'lens':
gmod.namepara.genrelem[l] += ['deflprof']
#gmod.namepara.genrelemeval = [[] for l in gmod.indxpopl]
#for l in gmod.indxpopl:
# if gmod.typeelem[l].startswith('clus'):
# gmod.namepara.genrelemeval[l] = ['lgal', 'bgal', 'nobj']
# if gmod.typeelem[l] == 'clusvari':
# gmod.namepara.genrelemeval[l] += ['gwdt']
# if gmod.typeelem[l] == 'lens':
# gmod.namepara.genrelemeval[l] = ['lgal', 'bgal', 'defs', 'asca', 'acut']
# if gmod.typeelem[l].startswith('lghtline'):
# gmod.namepara.genrelemeval[l] = ['elin', 'spec']
# elif gmod.typeelem[l] == 'lghtgausbgrd':
# gmod.namepara.genrelemeval[l] = ['lgal', 'bgal', 'gwdt', 'spec']
# elif gmod.typeelem[l].startswith('lght'):
# gmod.namepara.genrelemeval[l] = ['lgal', 'bgal', 'spec']
## element legends
lablpopl = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gdat.numbgrid > 1:
if gmod.typeelem[l] == 'lghtpnts':
lablpopl[l] = 'FPS'
if gmod.typeelem[l] == 'lghtgausbgrd':
lablpopl[l] = 'BGS'
else:
if gmod.typeelem[l] == 'lghtpntspuls':
lablpopl[l] = 'Pulsar'
elif gmod.typeelem[l].startswith('lghtpntsagnn'):
lablpopl[l] = 'AGN'
elif gmod.typeelem[l].startswith('lghtpnts'):
lablpopl[l] = 'PS'
if gmod.typeelem[l] == 'lens':
lablpopl[l] = 'Subhalo'
if gmod.typeelem[l].startswith('clus'):
lablpopl[l] = 'Cluster'
if gmod.typeelem[l].startswith('lghtline'):
lablpopl[l]= 'Line'
setp_varb(gdat, 'lablpopl', valu=lablpopl, strgmodl=strgmodl)
if strgmodl == 'true':
gmod.indxpoplassc = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
if gmod.numbpopl == 3 and gmod.typeelem[1] == 'lens':
gmod.indxpoplassc[l] = [l]
else:
gmod.indxpoplassc[l] = gmod.indxpopl
# variables for which two dimensional histograms will be calculated
gmod.namepara.genrelemcorr = [[] for l in gmod.indxpopl]
if gdat.boolplotelemcorr:
for l in gmod.indxpopl:
for strgfeat in gmod.namepara.derielemodim[l]:
gmod.namepara.genrelemcorr[l].append(strgfeat)
# number of element parameters
if gmod.numbpopl > 0:
gmod.numbparagenrelemsing = np.zeros(gmod.numbpopl, dtype=int)
gmod.numbparaderielemsing = np.zeros(gmod.numbpopl, dtype=int)
gmod.numbparaelemsing = np.zeros(gmod.numbpopl, dtype=int)
gmod.numbparagenrelem = np.zeros(gmod.numbpopl, dtype=int)
gmod.numbparagenrelemcuml = np.zeros(gmod.numbpopl, dtype=int)
gmod.numbparagenrelemcumr = np.zeros(gmod.numbpopl, dtype=int)
gmod.numbparaderielem = np.zeros(gmod.numbpopl, dtype=int)
gmod.numbparaelem = np.zeros(gmod.numbpopl, dtype=int)
for l in gmod.indxpopl:
# number of generative element parameters for a single element of a specific population
gmod.numbparagenrelemsing[l] = len(gmod.namepara.genrelem[l])
# number of derived element parameters for a single element of a specific population
gmod.numbparaderielemsing[l] = len(gmod.namepara.derielem[l])
# number of element parameters for a single element of a specific population
gmod.numbparaelemsing[l] = len(gmod.namepara.elem[l])
# number of generative element parameters for all elements of a specific population
gmod.numbparagenrelem[l] = gmod.numbparagenrelemsing[l] * gmod.maxmpara.numbelem[l]
# number of generative element parameters up to the beginning of a population
gmod.numbparagenrelemcuml[l] = np.sum(gmod.numbparagenrelem[:l])
# number of generative element parameters up to the end of a population
gmod.numbparagenrelemcumr[l] = np.sum(gmod.numbparagenrelem[:l+1])
# number of derived element parameters for all elements of a specific population
gmod.numbparaderielem[l] = gmod.numbparaderielemsing[l] * gmod.numbelem[l]
# number of element parameters for all elements of a specific population
gmod.numbparaelem[l] = gmod.numbparaelemsing[l] * gmod.numbelem[l]
# number of generative element parameters summed over all populations
gmod.numbparagenrelemtotl = np.sum(gmod.numbparagenrelem)
# number of derived element parameters summed over all populations
gmod.numbparaderielemtotl = np.sum(gmod.numbparaderielem)
# number of element parameters summed over all populations
gmod.numbparaelemtotl = np.sum(gmod.numbparaderielem)
gmod.indxparagenrelemsing = []
for l in gmod.indxpopl:
gmod.indxparagenrelemsing.append(np.arange(gmod.numbparagenrelemsing[l]))
gmod.indxparaderielemsing = []
for l in gmod.indxpopl:
gmod.indxparaderielemsing.append(np.arange(gmod.numbparaderielemsing[l]))
gmod.indxparaelemsing = []
for l in gmod.indxpopl:
gmod.indxparaelemsing.append(np.arange(gmod.numbparaelemsing[l]))
# size of the auxiliary variable propobability density vector
if gmod.maxmpara.numbelemtotl > 0:
gmod.numblpri = 3 + gmod.numbparagenrelem * gmod.numbpopl
else:
gmod.numblpri = 0
if gdat.penalpridiff:
gmod.numblpri += 1
indxlpri = np.arange(gmod.numblpri)
# append the population tags to element parameter names
#for l in gmod.indxpopl:
# gmod.namepara.genrelem[l] = [gmod.namepara.genrelem[l][g] + 'pop%d' % l for g in gmod.indxparagenrelemsing[l]]
gmod.boolcompposi = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
gmod.boolcompposi[l] = np.zeros(gmod.numbparagenrelemsing[l], dtype=bool)
if gmod.typeelem[l].startswith('lghtline'):
gmod.boolcompposi[l][0] = True
else:
gmod.boolcompposi[l][0] = True
gmod.boolcompposi[l][1] = True
# list of strings across all populations
## all (generative and derived) element parameters
gmod.numbparaelem = len(gmod.namepara.elem)
gmod.indxparaelem = np.arange(gmod.numbparaelem)
# flattened list of generative element parameters
gmod.listnameparagenfelem = []
for l in gmod.indxpopl:
for nameparagenrelem in gmod.namepara.genrelem[l]:
gmod.listnameparagenfelem.append(nameparagenrelem + 'pop%d' % l)
# concatenated list of flattened generative and derived element parameters
gmod.listnameparatotlelem = gmod.listnameparagenfelem + gmod.namepara.derielem
gmod.numbparaelem = np.empty(gmod.numbpopl, dtype=int)
for l in gmod.indxpopl:
gmod.numbparaelem[l] = len(gmod.namepara.elem[l])
numbdeflsubhplot = 2
numbdeflsingplot = numbdeflsubhplot
if gmod.numbparaelem > 0:
numbdeflsingplot += 3
gmod.convdiffanyy = True in convdiff
cntr = tdpy.cntr()
if gmod.boollens:
adishost = gdat.adisobjt(redshost)
adissour = gdat.adisobjt(redssour)
adishostsour = adissour - (1. + redshost) / (1. + redssour) * adishost
massfrombein = retr_massfrombein(gdat, adissour, adishost, adishostsour)
mdencrit = retr_mdencrit(gdat, adissour, adishost, adishostsour)
# object of parameter indices
gmod.indxpara = tdpy.gdatstrt()
# define parameter indices
if gmod.numbparaelem > 0:
# number of elements
#gmod.indxpara.numbelem = np.empty(gmod.numbpopl, dtype=int)
for l in gmod.indxpopl:
indx = cntr.incr()
setattr(gmod.indxpara, 'numbelempop%d' % l, indx)
#gmod.indxpara.numbelem[l] = indx
# hyperparameters
## mean number of elements
if gmod.typemodltran == 'pois':
#gmod.indxpara.meanelem = np.empty(gmod.numbpopl, dtype=int)
for l in gmod.indxpopl:
if gmod.maxmpara.numbelem[l] > 0:
indx = cntr.incr()
setattr(gmod.indxpara, 'meanelempop%d' % l, indx)
#gmod.indxpara.meanelem[l] = indx
## parameters parametrizing priors on element parameters
liststrgvarb = []
for l in gmod.indxpopl:
if gmod.maxmpara.numbelem[l] > 0:
for strgpdfnelemgenr, strgfeat in zip(gmod.listscalparagenrelem[l], gmod.namepara.genrelem[l]):
if strgpdfnelemgenr == 'expo' or strgpdfnelemgenr == 'dexp':
liststrgvarb += [strgfeat + 'distscal']
if strgpdfnelemgenr == 'powr':
liststrgvarb += ['slopprio' + strgfeat + 'pop%d' % l]
if strgpdfnelemgenr == 'dpow':
liststrgvarb += [strgfeat + 'distbrek']
liststrgvarb += [strgfeat + 'sloplowr']
liststrgvarb += [strgfeat + 'slopuppr']
if strgpdfnelemgenr == 'gausmean' or strgpdfnelemgenr == 'lnormean':
liststrgvarb += [strgfeat + 'distmean']
if strgpdfnelemgenr == 'gausstdv' or strgpdfnelemgenr == 'lnorstdv':
liststrgvarb += [strgfeat + 'diststdv']
if strgpdfnelemgenr == 'gausmeanstdv' or strgpdfnelemgenr == 'lnormeanstdv':
liststrgvarb += [nameparagenrelem + 'distmean', nameparagenrelem + 'diststdv']
for strgvarb in liststrgvarb:
setattr(gmod.indxpara, strgvarb, np.zeros(gmod.numbpopl, dtype=int) - 1)
for l in gmod.indxpopl:
strgpopl = 'pop%d' % l
if gmod.maxmpara.numbelem[l] > 0:
for k, nameparagenrelem in enumerate(gmod.namepara.genrelem[l]):
if gmod.listscalparagenrelem[l][k] == 'self':
continue
indx = cntr.incr()
if gmod.listscalparagenrelem[l][k] == 'dpow':
for nametemp in ['brek', 'sloplowr', 'slopuppr']:
strg = '%s' % nametemp + nameparagenrelem
setattr(gmod.indxpara, strg, indx)
setattr(gmod.indxpara, strg, indx)
else:
if gmod.listscalparagenrelem[l][k] == 'expo' or gmod.listscalparagenrelem[l][k] == 'dexp':
strghypr = 'scal'
if gmod.listscalparagenrelem[l][k] == 'powr':
strghypr = 'slop'
if gmod.listscalparagenrelem[l][k] == 'gausmean' or gmod.listscalparagenrelem[l][k] == 'gausmeanstdv' or \
gmod.listscalparagenrelem[l][k] == 'lnormean' or gmod.listscalparagenrelem[l][k] == 'lnormeanstdv':
strghypr = 'mean'
if gmod.listscalparagenrelem[l][k] == 'gausstdv' or gmod.listscalparagenrelem[l][k] == 'gausmeanstdv' or \
gmod.listscalparagenrelem[l][k] == 'lnorstdv' or gmod.listscalparagenrelem[l][k] == 'lnormeanstdv':
strghypr = 'stdv'
strg = strghypr + 'prio' + nameparagenrelem + 'pop%d' % l
setattr(gmod.indxpara, strg, indx)
# group PSF parameters
if gmod.typeevalpsfn == 'kern' or gmod.typeevalpsfn == 'full':
for m in gdat.indxevtt:
for i in gdat.indxener:
setattr(gmod.indxpara, 'sigcen%02devt%d' % (i, m), cntr.incr())
if gmod.typemodlpsfn == 'doubking' or gmod.typemodlpsfn == 'singking':
setattr(gmod.indxpara, 'gamcen%02devt%d' % (i, m), cntr.incr())
if gmod.typemodlpsfn == 'doubking':
setattr(gmod.indxpara, 'sigten%02devt%d' % (i, m), cntr.incr())
setattr(gmod.indxpara, 'gamten%02devt%d' % (i, m), cntr.incr())
setattr(gmod.indxpara, 'ffenen%02devt%d' % (i, m), cntr.incr())
gmod.indxpara.psfp = []
for strg, valu in gmod.indxpara.__dict__.items():
if strg.startswith('sigce') or strg.startswith('sigte') or strg.startswith('gamce') or strg.startswith('gamte') or strg.startswith('psffe'):
gmod.indxpara.psfp.append(valu)
gmod.indxpara.psfp = np.array(gmod.indxpara.psfp)
gmod.numbpsfptotlevtt = gdat.numbevtt * gmod.numbpsfptotl
gmod.numbpsfptotlener = gdat.numbener * gmod.numbpsfptotl
numbpsfp = gmod.numbpsfptotl * gdat.numbener * gdat.numbevtt
indxpsfpform = np.arange(numbpsfpform)
indxpsfptotl = np.arange(gmod.numbpsfptotl)
indxpsfp = np.arange(numbpsfp)
gmod.indxpara.psfp = np.sort(gmod.indxpara.psfp)
gmod.indxparapsfpinit = gmod.indxpara.psfp[0]
# group background parameters
gmod.indxpara.bacp = []
for c in gmod.indxback:
if gmod.boolspecback[c]:
indx = cntr.incr()
setattr(gmod.indxpara, 'bacpback%04d' % c, indx)
gmod.indxpara.bacp.append(indx)
else:
for i in gdat.indxener:
indx = cntr.incr()
setattr(gmod.indxpara, 'bacpback%04den%02d' % (c, i), indx)
gmod.indxpara.bacp.append(indx)
gmod.indxpara.bacp = np.array(gmod.indxpara.bacp)
# temp
#gmod.indxpara.anglsour = []
#gmod.indxpara.anglhost = []
#gmod.indxpara.angllens = []
if gmod.typeemishost != 'none':
gmod.indxpara.specsour = []
gmod.indxpara.spechost = []
if gmod.boollens:
gmod.indxpara.lgalsour = cntr.incr()
gmod.indxpara.bgalsour = cntr.incr()
gmod.indxpara.fluxsour = cntr.incr()
if gdat.numbener > 1:
gmod.indxpara.sindsour = cntr.incr()
gmod.indxpara.sizesour = cntr.incr()
gmod.indxpara.ellpsour = cntr.incr()
gmod.indxpara.anglsour = cntr.incr()
if gmod.typeemishost != 'none' or gmod.boollens:
for e in gmod.indxsersfgrd:
if gmod.typeemishost != 'none':
setattr(gmod.indxpara, 'lgalhostisf%d' % e, cntr.incr())
setattr(gmod.indxpara, 'bgalhostisf%d' % e, cntr.incr())
setattr(gmod.indxpara, 'fluxhostisf%d' % e, cntr.incr())
if gdat.numbener > 1:
setattr(gmod.indxpara, 'sindhostisf%d' % e, cntr.incr())
setattr(gmod.indxpara, 'sizehostisf%d' % e, cntr.incr())
if gmod.boollens:
setattr(gmod.indxpara, 'beinhostisf%d' % e, cntr.incr())
if gmod.typeemishost != 'none':
setattr(gmod.indxpara, 'ellphostisf%d' % e, cntr.incr())
setattr(gmod.indxpara, 'anglhostisf%d' % e, cntr.incr())
setattr(gmod.indxpara, 'serihostisf%d' % e, cntr.incr())
if gmod.boollens:
gmod.indxpara.sherextr = cntr.incr()
gmod.indxpara.sangextr = cntr.incr()
gmod.indxpara.sour = []
if gmod.boollens and gmod.typeemishost == 'none':
raise Exception('Lensing cannot be modeled without host galaxy emission.')
# collect groups of parameters
if gdat.typeexpr == 'hubb':
gmod.listnamecomplens = ['hostlght', 'hostlens', 'sour', 'extr']
for namecomplens in gmod.listnamecomplens:
setattr(gmod, 'liststrg' + namecomplens, [])
setattr(gmod.indxpara, namecomplens, [])
if gmod.boollens or gmod.typeemishost != 'none':
gmod.liststrghostlght += ['lgalhost', 'bgalhost', 'ellphost', 'anglhost']
gmod.liststrghostlens += ['lgalhost', 'bgalhost', 'ellphost', 'anglhost']
if gmod.typeemishost != 'none':
gmod.liststrghostlght += ['fluxhost', 'sizehost', 'serihost']
if gdat.numbener > 1:
gmod.liststrghostlght += ['sindhost']
if gmod.boollens:
gmod.liststrghostlens += ['beinhost']
gmod.liststrgextr += ['sherextr', 'sangextr']
gmod.liststrgsour += ['lgalsour', 'bgalsour', 'fluxsour', 'sizesour', 'ellpsour', 'anglsour']
if gdat.numbener > 1:
gmod.liststrgsour += ['sindsour']
for strg, valu in gmod.__dict__.items():
if isinstance(valu, list) or isinstance(valu, np.ndarray):
continue
if gdat.typeexpr == 'hubb':
for namecomplens in gmod.listnamecomplens:
for strgtemp in getattr(gmod, 'liststrg' + namecomplens):
if strg[12:].startswith(strgtemp):
if isinstance(valu, list):
for valutemp in valu:
gmod['indxparagenr' + namecomplens].append(valutemp)
else:
gmod['indxparagenr' + namecomplens].append(valu)
# remove indxpara. from strg
strg = strg[12:]
if strg.startswith('fluxsour') or strg.startswith('sindsour'):
gmod.indxpara.specsour.append(valu)
if strg.startswith('fluxhost') or strg.startswith('sindhost'):
gmod.indxpara.spechost.append(valu)
if gmod.boollens or gmod.boolhost:
gmod.indxpara.host = gmod.indxparahostlght + gmod.indxparahostlens
gmod.indxpara.lens = gmod.indxpara.host + gmod.indxpara.sour + gmod.indxpara.extr
## number of model spectral parameters for each population
#numbspep = np.empty(gmod.numbpopl, dtype=int)
#liststrgspep = [[] for l in range(gmod.numbpopl)]
#for l in gmod.indxpopl:
# if gdat.numbener > 1:
# liststrgspep[l] += ['sind']
# if gmod.spectype[l] == 'expc':
# liststrgspep[l] += ['expc']
# if gmod.spectype[l] == 'curv':
# liststrgspep[l] = ['curv']
# numbspep[l] = len(liststrgspep[l])
def setp_paragenrscalbase(gdat, strgmodl='fitt'):
'''
Setup labels and scales for base parameters
'''
print('setp_paragenrscalbase(): Building the %s model base paremeter names and scales...' % strgmodl)
gmod = getattr(gdat, strgmodl)
listlablback = []
listlablback = []
for nameback in gmod.listnameback:
if nameback == 'isot':
listlablback.append('Isotropic')
listlablback.append(r'$\mathcal{I}$')
if nameback == 'fdfm':
listlablback.append('FDM')
listlablback.append(r'$\mathcal{D}$')
if nameback == 'dark':
listlablback.append('NFW')
listlablback.append(r'$\mathcal{D}_{dark}$')
if nameback == 'part':
listlablback.append('Particle Back.')
listlablback.append(r'$\mathcal{I}_p$')
# background templates
listlablsbrt = deepcopy(listlablback)
numblablsbrt = 0
for l in gmod.indxpopl:
if gmod.boolelemsbrt[l]:
listlablsbrt.append(gmod.lablpopl[l])
listlablsbrt.append(gmod.lablpopl[l] + ' subt')
numblablsbrt += 2
if gmod.boollens:
listlablsbrt.append('Source')
numblablsbrt += 1
if gmod.typeemishost != 'none':
for e in gmod.indxsersfgrd:
listlablsbrt.append('Host %d' % e)
numblablsbrt += 1
if gmod.numbpopl > 0:
if 'clus' in gmod.typeelem or 'clusvari' in gmod.typeelem:
listlablsbrt.append('Uniform')
numblablsbrt += 1
listlablsbrtspec = ['Data']
listlablsbrtspec += deepcopy(listlablsbrt)
if len(listlablsbrt) > 1:
listlablsbrtspec.append('Total Model')
numblablsbrtspec = len(listlablsbrtspec)
# number of generative parameters per element, depends on population
#numbparaelem = gmod.numbparagenrelem + numbparaelemderi
# maximum total number of parameters
#numbparagenrfull = gmod.numbparagenrbase + gmod.numbparaelem
#numbparaelemkind = gmod.numbparagenrbase
#for l in gmod.indxpopl:
# numbparaelemkind += gmod.numbparagenrelemsing[l]
#nameparagenrbase
#gmod.namepara.genrelem
#listnameparaderifixd
#listnameparaderielem
#gmod.namepara.genrelemextd = gmod.namepara.genrelem * maxm.numbelem
#listnameparaderielemextd = gmod.namepara.genrelem * maxm.numbelem
gmod.listindxparakindscal = {}
for scaltype in gdat.listscaltype:
gmod.listindxparakindscal[scaltype] = np.where(scaltype == gmod.listscalparakind)[0]
#
## stack
## gmod.listnameparastck
#gmod.listnameparastck = np.zeros(gmod.maxmnumbpara, dtype=object)
#gmod.listscalparastck = np.zeros(gmod.maxmnumbpara, dtype=object)
#
#gmod.listnameparastck[gmod.indxparagenrbase] = gmod.nameparagenrbase
#gmod.listscalparastck[gmod.indxparagenrbase] = gmod.listscalparagenrbase
#for k in range(gmod.numbparaelem):
# for l in gmod.indxpopl:
# if k >= gmod.numbparagenrelemcuml[l]:
# indxpopltemp = l
# indxelemtemp = (k - gmod.numbparagenrelemcuml[indxpopltemp]) // gmod.numbparagenrelemsing[indxpopltemp]
# gmod.indxparagenrelemtemp = (k - gmod.numbparagenrelemcuml[indxpopltemp]) % gmod.numbparagenrelemsing[indxpopltemp]
# break
# gmod.listnameparastck[gmod.numbparagenrbase+k] = '%spop%d%04d' % (gmod.namepara.genrelem[indxpopltemp][gmod.indxparagenrelemtemp], indxpopltemp, indxelemtemp)
# gmod.listscalparastck[gmod.numbparagenrbase+k] = gmod.listscalparagenrelem[indxpopltemp][gmod.indxparagenrelemtemp]
#
#
#if np.where(gmod.listscalpara == 0)[0].size > 0:
# print('gmod.listscalpara[gmod.indxparagenrbase]')
# print(gmod.listscalpara[gmod.indxparagenrbase])
# raise Exception('')
#
## labels and scales for variables
if gmod.boollens:
setattr(gmod.lablrootpara, 'masssubhintg', r'$M_{\rm{sub}}$')
setattr(gmod.lablrootpara, 'masssubhdelt', r'$\rho_{\rm{sub}}$')
setattr(gmod.lablrootpara, 'masssubhintgbein', r'$M_{\rm{sub,E}}$')
setattr(gmod.lablrootpara, 'masssubhdeltbein', r'$\rho_{\rm{sub,E}}$')
setattr(gmod.lablrootpara, 'masssubhintgunit', '$10^9 M_{\odot}$')
setattr(gmod.lablrootpara, 'masssubhdeltunit', '$M_{\odot}$/kpc')
setattr(gmod.lablrootpara, 'masssubhintgbeinunit', '$10^9 M_{\odot}$')
setattr(gmod.lablrootpara, 'masssubhdeltbeinunit', '$M_{\odot}$/kpc')
setattr(gmod.lablrootpara, 'fracsubhintg', r'f_{\rm{sub}}')
setattr(gmod.lablrootpara, 'fracsubhdelt', r'f_{\rho,\rm{sub}}')
setattr(gmod.lablrootpara, 'fracsubhintgbein', r'$f_{\rm{sub,E}}$')
setattr(gmod.lablrootpara, 'fracsubhdeltbein', r'$f_{\rho,\rm{sub,E}}$')
for e in gmod.indxsersfgrd:
setattr(gmod.lablrootpara, 'masshostisf%dbein' % e, r'$M_{\rm{hst,%d,C}}$' % e)
setattr(gmod.lablrootpara, 'masshostisf%dintg' % e, r'$M_{\rm{hst,%d<}}$' % e)
setattr(gmod.lablrootpara, 'masshostisf%ddelt' % e, r'$M_{\rm{hst,%d}}$' % e)
setattr(gmod.lablrootpara, 'masshostisf%dintgbein' % e, r'$M_{\rm{hst,E,%d<}}$' % e)
setattr(gmod.lablrootpara, 'masshostisf%ddeltbein' % e, r'$M_{\rm{hst,E,%d}}$' % e)
for namevarb in ['fracsubh', 'masssubh']:
for strgcalcmasssubh in gdat.liststrgcalcmasssubh:
for nameeval in ['', 'bein']:
setattr(gdat, 'scal' + namevarb + strgcalcmasssubh + nameeval, 'logt')
for e in gmod.indxsersfgrd:
setattr(gdat, 'scalmasshostisf%d' % e + 'bein', 'logt')
for strgcalcmasssubh in gdat.liststrgcalcmasssubh:
for nameeval in ['', 'bein']:
setattr(gdat, 'scalmasshostisf%d' % e + strgcalcmasssubh + nameeval, 'logt')
# scalar variable setup
gdat.lablhistcntplowrdfncsubten00evt0 = 'N_{pix,l}'
gdat.lablhistcntphigrdfncsubten00evt0 = 'N_{pix,h}'
gdat.lablhistcntplowrdfncen00evt0 = 'N_{pix,l}'
gdat.lablhistcntphigrdfncen00evt0 = 'N_{pix,h}'
gdat.lablbooldfncsubt = 'H'
gdat.lablpriofactdoff = r'$\alpha_{p}$'
gmod.scalpriofactdoff = 'self'
gdat.minmreds = 0.
gdat.maxmreds = 1.5
gdat.minmmagt = 19.
gdat.maxmmagt = 28.
gmod.scalpara.numbelem = 'logt'
gmod.scalpara.lliktotl = 'logt'
gdat.lablener = 'E'
#gdat.lablenertotl = '$%s$ [%s]' % (gdat.lablener, gdat.strgenerunit)
# width of the Gaussian clusters
gdat.lablgwdt = r'\sigma_G'
gdat.lablgang = r'\theta'
gdat.lablaang = r'\phi'
gdat.labllgalunit = gdat.lablgangunit
gdat.lablbgalunit = gdat.lablgangunit
gdat.lablanglfromhost = r'\theta_{\rm{0,hst}}'
gdat.lablanglfromhostunit = gdat.lablgangunit
gdat.labldefs = r'\alpha_s'
gdat.lablflux = 'f'
gdat.lablnobj = 'p'
gdat.lablelin = r'\mathcal{E}'
gdat.lablsbrt = r'\Sigma'
gdat.labldeflprof = r'\alpha_a'
gdat.labldeflprofunit = u'$^{\prime\prime}$'
gdat.strgenerkevv = 'keV'
gdat.strgenergevv = 'GeV'
gdat.strgenerergs = 'erg'
gdat.strgenerimum = '\mu m^{-1}'
gdat.labldefsunit = u'$^{\prime\prime}$'
gdat.lablprat = 'cm$^{-2}$ s$^{-1}$'
### labels for derived fixed dimensional parameters
if gdat.boolbinsener:
for i in gdat.indxener:
setattr(gmod.lablrootpara, 'fracsdenmeandarkdfncsubten%02d' % i, 'f_{D/ST,%d}' % i)
else:
gmod.lablrootpara.fracsdenmeandarkdfncsubt = 'f_{D/ST}'
setattr(gmod.lablrootpara, 'fracsdenmeandarkdfncsubt', 'f_{D/ST}')
### labels for background units
if gdat.typeexpr == 'ferm':
for nameenerscaltype in ['en00', 'en01', 'en02', 'en03']:
for labltemptemp in ['flux', 'sbrt']:
# define the label
if nameenerscaltype == 'en00':
strgenerscal = '%s' % labltemp
if nameenerscaltype == 'en01':
strgenerscal = 'E%s' % labltemp
if nameenerscaltype == 'en02':
strgenerscal = 'E^2%s' % labltemp
if nameenerscaltype == 'en03':
strgenerscal = '%s' % labltemp
labl = '%s' % strgenerscal
for nameenerunit in ['gevv', 'ergs', 'kevv', 'imum']:
strgenerunit = getattr(gdat, 'strgener' + nameenerunit)
if nameenerscaltype == 'en00':
strgenerscalunit = '%s$^{-1}$' % strgenerunit
if nameenerscaltype == 'en01':
strgenerscalunit = ''
if nameenerscaltype == 'en02':
strgenerscalunit = '%s' % strgenerunit
if nameenerscaltype == 'en03':
strgenerscalunit = '%s' % strgenerunit
# define the label unit
for namesoldunit in ['ster', 'degr']:
if labltemptemp == 'flux':
lablunit = '%s %s' % (strgenerscalunit, gdat.lablprat)
setattr(gmod.lablunitpara, 'lablflux' + nameenerscaltype + nameenerunit + 'unit', lablunit)
else:
if namesoldunit == 'ster':
lablunit = '%s %s sr$^{-1}$' % (strgenerscalunit, gdat.lablprat)
if namesoldunit == 'degr':
lablunit = '%s %s deg$^{-2}$' % (strgenerscalunit, gdat.lablprat)
setattr(gmod.lablunitpara, 'sbrt' + nameenerscaltype + nameenerunit + namesoldunit + 'unit', lablunit)
if gdat.boolbinsener:
gdat.lablfluxunit = getattr(gmod.lablunitpara, 'fluxen00' + gdat.nameenerunit + 'unit')
gdat.lablsbrtunit = getattr(gmod.lablunitpara, 'sbrten00' + gdat.nameenerunit + 'sterunit')
gdat.lablexpo = r'$\epsilon$'
gdat.lablexpounit = 'cm$^2$ s'
gdat.lablprvl = '$p$'
gdat.lablreds = 'z'
gdat.lablmagt = 'm_R'
gdat.lablper0 = 'P_0'
gmod.scalper0plot = 'logt'
gdat.labldglc = 'd_{gc}'
gmod.scaldglcplot = 'logt'
gdat.labldlos = 'd_{los}'
gmod.scaldlosplot = 'logt'
if gdat.typeexpr == 'ferm':
gdat.labldlosunit = 'kpc'
gdat.labllumi = r'L_{\gamma}'
if gdat.typeexpr == 'chan':
gdat.labldlosunit = 'Mpc'
gdat.labllumi = r'L_{X}'
gdat.labllum0 = r'L_{X, 0}'
gdat.lablgeff = r'\eta_{\gamma}'
gmod.scalgeffplot = 'logt'
gmod.scallumiplot = 'logt'
gdat.labllumiunit = 'erg s$^{-1}$'
gdat.labllum0unit = 'erg s$^{-1}$'
gdat.lablthet = r'\theta_{gc}'
gmod.scalthetplot = 'self'
gdat.lablphii = r'\phi_{gc}'
gmod.scalphiiplot = 'self'
setattr(gmod.lablrootpara, 'magf', 'B')
setattr(gdat, 'scalmagfplot', 'logt')
setattr(gmod.lablrootpara, 'per1', 'P_1')
if gdat.typedata == 'inpt':
gdat.minmpara.per0 = 1e-3
gdat.maxmpara.per0 = 1e1
gdat.minmpara.per1 = 1e-20
gdat.maxmpara.per1 = 1e-10
gdat.minmpara.per1 = 1e-20
gdat.maxmpara.per1 = 1e-10
gdat.minmpara.flux0400 = 1e-1
gdat.maxmpara.flux0400 = 1e4
setattr(gdat, 'scalper1plot', 'logt')
setattr(gmod.lablrootpara, 'flux0400', 'S_{400}')
setattr(gdat, 'scalflux0400plot', 'logt')
for q in gdat.indxrefr:
setattr(gmod.lablrootpara, 'aerr' + gdat.listnamerefr[q], '\Delta_{%d}' % q)
gdat.lablsigm = '\sigma_l'
gdat.lablgamm = '\gamma_l'
gdat.lablbcom = '\eta'
gdat.lablinfopost = 'D_{KL}'
gdat.lablinfopostunit = 'nat'
gdat.lablinfoprio = 'D_{KL,pr}'
gdat.lablinfopriounit = 'nat'
gdat.labllevipost = '\ln P(D)'
gdat.labllevipostunit = 'nat'
gdat.lablleviprio = '\ln P_{pr}(D)'
gdat.labllevipriounit = 'nat'
gdat.lablsind = 's'
if gdat.boolbinsener:
for i in gdat.indxenerinde:
setattr(gmod.lablrootpara, 'sindcolr%04d' % i, 's_%d' % i)
gdat.lablexpcunit = gdat.strgenerunit
gdat.labllliktotl = r'\ln P(D|M)'
gdat.labllpripena = r'\ln P(N)'
gdat.lablasca = r'\theta_s'
gdat.lablascaunit = gdat.lablgangunit
gdat.lablacut = r'\theta_c'
gdat.lablacutunit = gdat.lablgangunit
gdat.lablmcut = r'M_{c,n}'
gdat.lablmcutunit = r'$M_{\odot}$'
gdat.lablmcutcorr = r'\bar{M}_{c,n}'
gdat.lablmcutcorrunit = r'$M_{\odot}$'
gdat.lablspec = gdat.lablflux
gdat.lablspecunit = gdat.lablfluxunit
gdat.lablspecplot = gdat.lablflux
gdat.lablspecplotunit = gdat.lablfluxunit
gdat.lablcnts = 'C'
gdat.labldeltllik = r'\Delta_n \ln P(D|M)'
gdat.labldiss = r'\theta_{sa}'
gdat.labldissunit = gdat.lablgangunit
gdat.lablrele = r'\langle|\vec{\alpha}_n \cdot \vec{\nabla} k_l| \rangle'
gdat.lablrelc = r'\langle\vec{\alpha}_n \cdot \vec{\nabla} k_l \rangle'
gdat.lablreld = r'\langle|\vec{\alpha}_n \cdot \vec{\nabla} k_d| \rangle'
gdat.lablreln = r'\langle \Delta \theta_{pix} |\hat{\alpha}_n \cdot \vec{\nabla} k_l| / \alpha_{s,n} \rangle'
gdat.lablrelm = r'\langle |\vec{\nabla}_{\hat{\alpha}} k_l| / \alpha_{s,n} \rangle'
gdat.lablrelk = r'\langle |\vec{\nabla}_{\hat{\alpha}} k_l| / \alpha_{s,n} \rangle'
gdat.lablrelf = r'\langle |\vec{\nabla}_{\hat{\alpha}} k_l| / \alpha_{s,n} \rangle / k_m'
for q in gdat.indxrefr:
for l in gmod.indxpopl:
setp_varb(gdat, 'fdispop%dpop%d' % (l, q), minm=0., maxm=1., lablroot='$F_{%d%d}$' % (l, q))
setp_varb(gdat, 'cmplpop%dpop%d' % (l, q), minm=0., maxm=1., lablroot='$C_{%d%d}$' % (l, q))
if gdat.typeexpr == 'chan':
if gdat.anlytype == 'spec':
gdat.minmspec = 1e-2
gdat.maxmspec = 1e1
else:
gdat.minmspec = 1e-11
gdat.maxmspec = 1e-7
else:
gdat.minmspec = 1e-11
gdat.maxmspec = 1e-7
if gdat.typeexpr == 'ferm':
gdat.minmlumi = 1e32
gdat.maxmlumi = 1e36
elif gdat.typeexpr == 'chan':
if gdat.typedata == 'inpt':
gdat.minmlum0 = 1e42
gdat.maxmlum0 = 1e46
gdat.minmlumi = 1e41
gdat.maxmlumi = 1e45
try:
gdat.minmdlos
except:
if gdat.typeexpr == 'chan':
gdat.minmdlos = 1e7
gdat.maxmdlos = 1e9
else:
gdat.minmdlos = 6e3
gdat.maxmdlos = 1.1e4
if gdat.typeexpr == 'ferm':
gdat.minmcnts = 1e1
gdat.maxmcnts = 1e5
if gdat.typeexpr == 'chan':
if gdat.numbpixlfull == 1:
gdat.minmcnts = 1e4
gdat.maxmcnts = 1e8
else:
gdat.minmcnts = 1.
gdat.maxmcnts = 1e3
if gdat.typeexpr == 'hubb':
gdat.minmcnts = 1.
gdat.maxmcnts = 1e3
if gdat.typeexpr == 'fire':
gdat.minmcnts = 1.
gdat.maxmcnts = 1e3
gdat.minmspecplot = gdat.minmspec
gdat.maxmspecplot = gdat.maxmspec
gdat.minmdeltllik = 1.
gdat.maxmdeltllik = 1e3
gdat.minmdiss = 0.
gdat.maxmdiss = gdat.maxmgangdata * np.sqrt(2.)
gdat.minmrele = 1e-3
gdat.maxmrele = 1e1
gdat.minmreln = 1e-3
gdat.maxmreln = 1.
gdat.minmrelk = 1e-3
gdat.maxmrelk = 1.
gdat.minmrelf = 1e-5
gdat.maxmrelf = 1e-1
gdat.minmrelm = 1e-3
gdat.maxmrelm = 1e1
gdat.minmreld = 1e-3
gdat.maxmreld = 1e1
gdat.minmrelc = 1e-3
gdat.maxmrelc = 1.
gdat.minmmcut = 3e7
gdat.maxmmcut = 2e9
gdat.minmmcutcorr = gdat.minmmcut
gdat.maxmmcutcorr = gdat.maxmmcut
if gdat.boolbinsspat:
gdat.minmbein = 0.
gdat.maxmbein = 1. / gdat.anglfact
# scalar variables
if gdat.boolbinsspat:
gdat.minmdeflprof = 1e-3 / gdat.anglfact
gdat.maxmdeflprof = 0.1 / gdat.anglfact
#gdat.minmfracsubh = 0.
#gdat.maxmfracsubh = 0.3
#gmod.scalfracsubh = 'self'
#gdat.minmmasshost = 1e10
#gdat.maxmmasshost = 1e13
#gmod.scalmasshost = 'self'
#
#gdat.minmmasssubh = 1e8
#gdat.maxmmasssubh = 1e10
#gmod.scalmasssubh = 'self'
# collect groups of parameter indices into lists
## labels and scales for base parameters
gmod.nameparagenrbase = []
for name, k in gmod.indxpara.__dict__.items():
if not np.isscalar(k):
print('name')
print(name)
print('temp: no nonscalar should be here!')
continue
gmod.nameparagenrbase.append(name)
gmod.numbparagenrbase = len(gmod.nameparagenrbase)
gmod.indxparagenrbase = np.arange(gmod.numbparagenrbase)
gmod.indxparagenrbasestdv = gmod.indxparagenrbase[gmod.numbpopl:]
## list of scalar variable names
gmod.namepara.scal = list(gmod.nameparagenrbase)
gmod.namepara.scal += ['lliktotl']
# derived parameters
print('Determining the list of derived, fixed-dimensional parameter names...')
gmod.namepara.genrelemextd = [[[] for g in gmod.indxparagenrelemsing[l]] for l in gmod.indxpopl]
gmod.namepara.derielemextd = [[[] for k in gmod.indxparaderielemsing[l]] for l in gmod.indxpopl]
gmod.namepara.genrelemflat = []
gmod.namepara.derielemflat = []
gmod.namepara.genrelemextdflat = []
gmod.namepara.derielemextdflat = []
for l in gmod.indxpopl:
for g in gmod.indxparagenrelemsing[l]:
gmod.namepara.genrelemflat.append(gmod.namepara.genrelem[l][g] + 'pop%d' % l)
for d in range(gmod.maxmpara.numbelem[l]):
gmod.namepara.genrelemextd[l][g].append(gmod.namepara.genrelem[l][g] + 'pop%d' % l + '%04d' % d)
gmod.namepara.genrelemextdflat.append(gmod.namepara.genrelemextd[l][g][d])
for k in gmod.indxparaderielemsing[l]:
gmod.namepara.derielemflat.append(gmod.namepara.derielem[l][k] + 'pop%d' % l)
for d in range(gmod.maxmpara.numbelem[l]):
gmod.namepara.derielemextd[l][k].append(gmod.namepara.derielem[l][k] + 'pop%d' % l + '%04d' % d)
gmod.namepara.derielemextdflat.append(gmod.namepara.derielemextd[l][k][d])
# list of element parameter names (derived and generative), counting label-degenerate element parameters only once
gmod.namepara.elem = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
gmod.namepara.elem[l].extend(gmod.namepara.genrelem[l])
gmod.namepara.elem[l].extend(gmod.namepara.derielem[l])
gmod.namepara.elemflat = []
for l in gmod.indxpopl:
gmod.namepara.elemflat.extend(gmod.namepara.elem[l])
gmod.namepara.genrelemdefa = deepcopy(gmod.namepara.elemflat)
if gmod.boolelemlghtanyy:
for strgfeat in ['sind', 'curv', 'expc'] + ['sindcolr%04d' % i for i in gdat.indxenerinde]:
if not strgfeat in gmod.namepara.genrelemdefa:
gmod.namepara.genrelemdefa.append(strgfeat)
# list of flattened generative element parameter names, counting label-degenerate element parameters only once
gmod.namepara.genrelemkind = gmod.namepara.genrelemflat + gmod.namepara.derielemflat
gmod.numbparagenrelemkind = len(gmod.namepara.genrelemkind)
#gmod.inxparagenrscalelemkind = np.arange(gmod.numbparagenrelemkind)
gmod.inxparagenrscalelemkind = tdpy.gdatstrt()
gmod.numbparagenrelemextdflat = len(gmod.namepara.genrelemextdflat)
gmod.indxparagenrelemextdflat = np.arange(gmod.numbparagenrelemextdflat)
# list of parameter names (derived and generative), counting label-degenerate element parameters only once, element lists flattened
gmod.namepara.kind = gmod.nameparagenrbase + gmod.listnameparaderitotl + gmod.namepara.genrelemflat + gmod.namepara.derielemflat
gmod.numbparakind = len(gmod.namepara.kind)
gmod.indxparakind = np.arange(gmod.numbparakind)
# list of generative parameter names, separately including all label-degenerate element parameters, element lists flattened
gmod.namepara.genrscalfull = gmod.nameparagenrbase + gmod.namepara.genrelemextdflat
gmod.namepara.genrscalfull = np.array(gmod.namepara.genrscalfull)
gmod.numbparagenrfull = len(gmod.namepara.genrscalfull)
gmod.indxparagenrfull = np.arange(gmod.numbparagenrfull)
# list of generative parameter names, counting label-degenerate element parameters only once, element lists flattened
gmod.listnameparagenrscal = gmod.nameparagenrbase + gmod.namepara.genrelemflat
gmod.numbparagenr = len(gmod.listnameparagenrscal)
gmod.indxparagenr = np.arange(gmod.numbparagenr)
# list of parameter names (derived and generative), element lists flattened
gmod.listnameparatotl = gmod.nameparagenrbase + gmod.listnameparaderitotl + \
gmod.namepara.genrelemextdflat + gmod.namepara.derielemextdflat
gmod.nameparagenrbase = np.array(gmod.nameparagenrbase)
for e in gmod.indxsersfgrd:
gmod.namepara.scal += ['masshost' + strgsersfgrd + 'bein']
for strgcalcmasssubh in gdat.liststrgcalcmasssubh:
gmod.namepara.scal += ['masshost' + strgsersfgrd + strgcalcmasssubh + 'bein']
if gmod.numbparaelem > 0:
if gmod.boollenssubh:
for strgcalcmasssubh in gdat.liststrgcalcmasssubh:
gmod.namepara.scal += ['masssubh' + strgcalcmasssubh + 'bein', 'fracsubh' + strgcalcmasssubh + 'bein']
if gmod.numbparaelem > 0:
gmod.namepara.scal += ['lpripena']
if False and gmod.boolelemsbrtdfncanyy:
for strgbins in ['lowr', 'higr']:
gmod.namepara.scal += ['histcntp%sdfncen00evt0' % strgbins]
gmod.namepara.scal += ['histcntp%sdfncsubten00evt0' % strgbins]
for i in gdat.indxener:
gmod.namepara.scal += ['fracsdenmeandarkdfncsubten%02d' % i]
gmod.namepara.scal += ['booldfncsubt']
if gmod.numbparaelem > 0:
for q in gdat.indxrefr:
if gdat.boolasscrefr[q]:
for l in gmod.indxpopl:
gmod.namepara.scal += ['cmplpop%dpop%d' % (l, q)]
gmod.namepara.scal += ['fdispop%dpop%d' % (q, l)]
gmod.numbvarbscal = len(gmod.namepara.scal)
gmod.indxvarbscal = np.arange(gmod.numbvarbscal)
# determine total label
gmod.listnameparaglob = gmod.namepara.kind + gmod.namepara.genrelemextdflat + gmod.namepara.derielemextdflat
gmod.listnameparaglob += ['cntpmodl']
for l in gmod.indxpopl:
for g in gmod.indxparagenrelemsing[l]:
if not gmod.namepara.genrelem[l][g] in gmod.listnameparaglob:
gmod.listnameparaglob.append(gmod.namepara.genrelem[l][g])
gmod.listnameparaglob.append(gmod.namepara.derielem[l][g])
for name in gmod.listnameparaglob:
lablroot = getattr(gmod.lablrootpara, name)
lablunit = getattr(gmod.lablunitpara, name)
labltotl = tdpy.retr_labltotlsing(lablroot, lablunit)
setattr(gmod.labltotlpara, name, labltotl)
# define fact
for l in gmod.indxpopl:
for k in gmod.indxparakind:
name = gmod.namepara.kind[k]
scal = getattr(gmod.scalpara, name)
if scal == 'self' or scal == 'logt':
minm = getattr(gmod.minmpara, name)
maxm = getattr(gmod.maxmpara, name)
if scal == 'self':
fact = maxm - minm
if scal == 'logt':
fact = np.log(maxm / minm)
if fact == 0:
print('name')
print(name)
raise Exception('')
setattr(gmod.factpara, name, fact)
if gmod.numbparaelem > 0:
gmod.indxparagenrfulleleminit = gmod.indxparagenrbase[-1] + 1
else:
gmod.indxparagenrfulleleminit = -1
## arrays of parameter features (e.g., minm, maxm, labl, scal, etc.)
for featpara in gdat.listfeatparalist:
gmodfeat = getattr(gmod, featpara + 'para')
### elements
#for strgtypepara in gdat.liststrgtypepara:
# listname = getattr(gmod.namepara, strgtypepara + 'elem')
# listfeat = [[] for l in gmod.indxpopl]
# listfeatflat = []
# for l in gmod.indxpopl:
#
# numb = getattr(gmod, 'numbpara' + strgtypepara + 'elemsing')[l]
# listfeat[l] = [[] for k in range(numb)]
# for k in range(numb):
# scal = getattr(gmod.scalpara, listname[l][k])
# if featpara == 'fact' and not (scal == 'self' or scal == 'logt'):
# continue
# if featpara == 'mean' and (scal != 'gaus' and scal != 'lnor'):
# continue
# if featpara == 'stdv' and (scal != 'gaus' and scal != 'lnor'):
# continue
#
# if strgtypepara == 'genr':
# strgextn = 'pop%d' % l
# else:
# strgextn = ''
# print('featpara')
# print(featpara)
# print('listname')
# print(listname)
# listfeat[l][k] = getattr(gmodfeat, listname[l][k] + strgextn)
# listfeatflat.append(listfeat[l][k])
# setattr(gmodfeat, strgtypepara + 'elem', listfeat)
# setattr(gmodfeat, strgtypepara + 'elemflat', listfeatflat)
### groups of parameters inside the parameter vector
### 'base': all fixed-dimensional generative parameters
### 'full': all generative parameters
for strggroppara in ['base', 'full']:
indx = getattr(gmod, 'indxparagenr' + strggroppara)
feat = [0. for k in indx]
for attr, valu in gmod.indxpara.__dict__.items():
if not np.isscalar(valu):
continue
scal = getattr(gmod.scalpara, attr)
if not (scal == 'self' or scal == 'logt') and featpara == 'fact':
continue
if scal != 'gaus' and (featpara == 'mean' or featpara == 'stdv'):
print('Mean or Std for non-Gaussian')
continue
if featpara == 'name':
feat[valu] = attr
else:
feat[valu] = getattr(gmodfeat, attr)
feat = np.array(feat)
setattr(gmodfeat, 'genr' + strggroppara, feat)
#print('gmod.minmpara')
#for attr, varb in gmod.minmpara.__dict__.items():
# print(attr, varb)
#print('gmod.maxmpara')
#for attr, varb in gmod.maxmpara.__dict__.items():
# print(attr, varb)
#print('gmod.scalpara')
#for attr, varb in gmod.scalpara.__dict__.items():
# print(attr, varb)
#raise Exception('')
## population groups
### number of elements
for strgvarb in ['numbelem', 'meanelem']:
listindxpara = []
if strgmodl == 'true':
listpara = []
for strg, valu in gmod.indxpara.__dict__.items():
if strg.startswith(strgvarb + 'p'):
listindxpara.append(valu)
if strgmodl == 'true':
listpara.append(getattr(gmod.this, strg))
listindxpara = np.array(listindxpara)
setattr(gmod.indxpara, strgvarb, listindxpara)
if strgmodl == 'true':
listpara = np.array(listpara)
setattr(gmod, strgvarb, listpara)
### parameters of priors for element parameters
gmod.indxpara.prioelem = []
for strg, valu in gmod.indxpara.__dict__.items():
if strg == 'dist' and np.isscalar(valu):
gmod.indxpara.prioelem.append(valu)
gmod.indxpara.prioelem = np.array(gmod.indxpara.prioelem)
### hyperparameters
if gmod.typemodltran == 'pois':
gmod.indxpara.hypr = np.array(list(gmod.indxpara.prioelem) + list(gmod.indxpara.meanelem))
else:
gmod.indxpara.hypr = gmod.indxpara.prioelem
## generative base parameter indices for each scaling
gmod.listindxparagenrbasescal = dict()
for scaltype in gdat.listscaltype:
gmod.listindxparagenrbasescal[scaltype] = np.where(np.array(gmod.scalpara.genrbase) == scaltype)[0]
if gdat.booldiagmode:
if np.where(gmod.scalpara.genrfull == 0)[0].size > 0:
raise Exception('')
def plot_lens(gdat):
if gmod.boolelemdeflsubh:
xdat = gdat.binspara.angl[1:] * gdat.anglfact
lablxdat = gdat.labltotlpara.gang
listdeflscal = np.array([4e-2, 4e-2, 4e-2]) / gdat.anglfact
listanglscal = np.array([0.05, 0.1, 0.05]) / gdat.anglfact
listanglcutf = np.array([1., 1., 10.]) / gdat.anglfact
listasym = [False, False, False]
listydat = []
for deflscal, anglscal, anglcutf, asym in zip(listdeflscal, listanglscal, listanglcutf, listasym):
listydat.append(retr_deflcutf(gdat.binspara.angl[1:], deflscal, anglscal, anglcutf, asym=asym) * gdat.anglfact)
for scalxdat in ['self', 'logt']:
path = gdat.pathinitintr + 'deflcutf' + scalxdat + '.pdf'
tdpy.plot_gene(path, xdat, listydat, scalxdat=scalxdat, scalydat='logt', lablxdat=lablxdat, \
lablydat=r'$\alpha_n$ [$^{\prime\prime}$]', limtydat=[1e-3, 1.5e-2], limtxdat=[None, 2.])
# pixel-convoltuion of the Sersic profile
# temp -- y axis labels are wrong, should be per solid angle
xdat = gdat.binspara.lgalsers * gdat.anglfact
for n in range(gdat.numbindxsers + 1):
for k in range(gdat.numbhalfsers + 1):
if k != 5:
continue
path = gdat.pathinitintr + 'sersprofconv%04d%04d.pdf' % (n, k)
tdpy.plot_gene(path, xdat, gdat.sersprof[:, n, k], scalydat='logt', lablxdat=lablxdat, lablydat=gdat.lablfluxtotl, limtydat=[1e6, 1e12])
#path = gdat.pathinitintr + 'sersprofcntr%04d%04d.pdf' % (n, k)
#tdpy.plot_gene(path, xdat, gdat.sersprofcntr[:, n, k], scalydat='logt', lablxdat=lablxdat, lablydat=gdat.lablfluxtotl, limtydat=[1e6, 1e12])
path = gdat.pathinitintr + 'sersprofdiff%04d%04d.pdf' % (n, k)
tdpy.plot_gene(path, xdat, abs(gdat.sersprof[:, n, k] - gdat.sersprofcntr[:, n, k]) / gdat.sersprofcntr[:, n, k], \
scalydat='logt', lablxdat=lablxdat, lablydat=gdat.lablfluxtotl, limtydat=[1e-6, 1.])
path = gdat.pathinitintr + 'sersprofdiff%04d%04d.pdf' % (n, k)
tdpy.plot_gene(path, xdat, abs(gdat.sersprof[:, n, k] - gdat.sersprofcntr[:, n, k]) / gdat.sersprofcntr[:, n, k], scalxdat='logt', \
scalydat='logt', lablxdat=lablxdat, lablydat=gdat.lablfluxtotl, limtydat=[1e-6, 1.])
xdat = gdat.binspara.angl * gdat.anglfact
listspec = np.array([1e-19, 1e-18, 1e-18, 1e-18]) / gdat.anglfact
listsize = np.array([0.3, 1., 1., 1.]) / gdat.anglfact
listindx = np.array([4., 2., 4., 10.])
listydat = []
listlabl = []
for spec, size, indx in zip(listspec, listsize, listindx):
listydat.append(spec * retr_sbrtsersnorm(gdat.binspara.angl, size, indxsers=indx))
listlabl.append('$R_e = %.3g ^{\prime\prime}, n = %.2g$' % (size * gdat.anglfact, indx))
path = gdat.pathinitintr + 'sersprof.pdf'
tdpy.plot_gene(path, xdat, listydat, scalxdat='logt', scalydat='logt', lablxdat=lablxdat, lablydat=gdat.lablfluxtotl, \
listlegd=listlegd, listhlin=1e-7, limtydat=[1e-8, 1e0])
minmredshost = 0.01
maxmredshost = 0.4
minmredssour = 0.01
maxmredssour = 2.
numbreds = 200
retr_axis(gdat, 'redshost')
retr_axis(gdat, 'redssour')
gdat.meanpara.adishost = np.empty(numbreds)
for k in range(numbreds):
gdat.meanpara.adishost[k] = gdat.adisobjt(gdat.meanpara.redshost[k])
asca = 0.1 / gdat.anglfact
acut = 1. / gdat.anglfact
minmmass = np.zeros((numbreds + 1, numbreds + 1))
maxmmass = np.zeros((numbreds + 1, numbreds + 1))
for k, redshost in enumerate(gdat.binspara.redshost):
for n, redssour in enumerate(gdat.binspara.redssour):
if redssour > redshost:
adishost = gdat.adisobjt(redshost)
adissour = gdat.adisobjt(redssour)
adishostsour = adissour - (1. + redshost) / (1. + redssour) * adishost
factmcutfromdefs = retr_factmcutfromdefs(gdat, adissour, adishost, adishostsour, asca, acut)
minmmass[n, k] = np.log10(factmcutfromdefs * gdat.minmdefs)
maxmmass[n, k] = np.log10(factmcutfromdefs * gdat.maxmdefs)
#valulevl = np.linspace(7.5, 9., 5)
valulevl = [7.0, 7.3, 7.7, 8., 8.6]
figr, axis = plt.subplots(figsize=(gdat.plotsize, gdat.plotsize))
cont = axis.contour(gdat.binspara.redshost, gdat.binspara.redssour, minmmass, 10, colors='g', levels=valulevl)
axis.clabel(cont, inline=1, fontsize=20, fmt='%.3g')
axis.set_xlabel(r'$z_{\rm{hst}}$')
axis.set_ylabel(r'$z_{\rm{src}}$')
axis.set_title(r'$M_{c,min}$ [$M_{\odot}$]')
path = gdat.pathinitintr + 'massredsminm.pdf'
plt.tight_layout()
figr.savefig(path)
plt.close(figr)
valulevl = np.linspace(9., 11., 20)
figr, axis = plt.subplots(figsize=(gdat.plotsize, gdat.plotsize))
imag = axis.imshow(maxmmass, extent=[minmredshost, maxmredshost, minmredssour, maxmredssour], aspect='auto', vmin=9., vmax=11.)
cont = axis.contour(gdat.binspara.redshost, gdat.binspara.redssour, maxmmass, 10, colors='g', levels=valulevl)
axis.clabel(cont, inline=1, fontsize=15, fmt='%.3g')
axis.set_xlabel('$z_{hst}$')
axis.set_ylabel('$z_{src}$')
axis.set_title(r'$M_{c,max}$ [$M_{\odot}$]')
path = gdat.pathinitintr + 'massredsmaxm.pdf'
plt.colorbar(imag)
plt.tight_layout()
figr.savefig(path)
plt.close(figr)
figr, axis = plt.subplots(figsize=(gdat.plotsize, gdat.plotsize))
axis.plot(gdat.meanpara.redshost, gdat.meanpara.adishost * gdat.sizepixl * 1e-3)
axis.plot(gdat.meanpara.redshost, gdat.meanpara.adishost * 2. * gdat.maxmgangdata * 1e-3)
axis.set_xlabel('$z_h$')
axis.set_yscale('log')
axis.set_ylabel(r'$\lambda$ [kpc]')
path = gdat.pathinitintr + 'wlenreds.pdf'
plt.tight_layout()
figr.savefig(path)
plt.close(figr)
figr, axis = plt.subplots(figsize=(gdat.plotsize, gdat.plotsize))
fracacutasca = np.logspace(-1., 2., 20)
mcut = retr_mcutfrommscl(fracacutasca)
axis.lognp.log(fracacutasca, mcut)
axis.set_xlabel(r'$\tau_n$')
axis.set_ylabel(r'$M_{c,n} / M_{0,n}$')
axis.axhline(1., ls='--')
path = gdat.pathinitintr + 'mcut.pdf'
plt.tight_layout()
figr.savefig(path)
plt.close(figr)
def retr_listrtagprev(strgcnfg, pathpcat):
# list of PCAT run plot outputs
pathimag = pathpcat + '/imag/'
listrtag = fnmatch.filter(os.listdir(pathimag), '2*')
listrtagprev = []
for rtag in listrtag:
strgstat = pathpcat + '/data/outp/' + rtag
if chec_statfile(pathpcat, rtag, 'gdatmodipost', typeverb=0) and strgcnfg + '_' + rtag[16:].split('_')[-1] == rtag[16:]:
listrtagprev.append(rtag)
listrtagprev.sort()
return listrtagprev
def make_legd(axis, offs=None, loca=1, numbcols=1, ptch=None, line=None):
hand, labl = axis.get_legend_handles_labels()
legd = axis.legend(hand, labl, fancybox=True, frameon=True, bbox_to_anchor=offs, bbox_transform=axis.transAxes, ncol=numbcols, loc=loca, labelspacing=1, handlelength=2)
legd.get_frame().set_fill(True)
legd.get_frame().set_facecolor('white')
def setp_namevarbsing(gdat, gmod, strgmodl, strgvarb, popl, ener, evtt, back, isfr, iele):
if popl == 'full':
indxpopltemp = gmod.indxpopl
elif popl != 'none':
indxpopltemp = [popl]
if ener == 'full':
indxenertemp = gdat.indxener
elif ener != 'none':
indxenertemp = [ener]
if evtt == 'full':
indxevtttemp = gdat.indxevtt
elif evtt != 'none':
indxevtttemp = [evtt]
if back == 'full':
gmod.indxbacktemp = gmod.indxback
elif isinstance(back, int):
gmod.indxbacktemp = np.array([back])
liststrgvarb = []
if iele != 'none':
for l in gmod.indxpopl:
if iele == 'full':
listiele = np.arange(gmod.maxmpara.numbelem)
else:
listiele = [iele]
for k in listiele:
liststrgvarb.append(strgvarb + 'pop%d%04d' % (l, k))
if popl != 'none' and ener == 'none' and evtt == 'none' and back == 'none' and iele == 'none':
for l in indxpopltemp:
liststrgvarb.append(strgvarb + 'pop%d' % l)
if popl == 'none' and ener == 'none' and evtt == 'none' and back == 'none' and isfr != 'none':
for e in indxisfrtemp:
liststrgvarb.append(strgvarb + 'isf%d' % e)
if popl == 'none' and ener != 'none' and evtt != 'none' and back == 'none':
for i in indxenertemp:
for m in indxevtttemp:
liststrgvarb.append(strgvarb + 'en%02devt%d' % (i, m))
if popl == 'none' and ener != 'none' and evtt == 'none' and back != 'none':
for c in gmod.indxbacktemp:
for i in indxenertemp:
liststrgvarb.append(strgvarb + 'back%04den%02d' % (c, i))
if popl == 'none' and ener == 'none' and evtt == 'none' and back != 'none':
for c in gmod.indxbacktemp:
liststrgvarb.append(strgvarb + 'back%04d' % c)
if popl == 'none' and ener != 'none' and evtt == 'none' and back == 'none':
for i in indxenertemp:
liststrgvarb.append(strgvarb + 'en%02d' % i)
if popl == 'none' and ener == 'none' and evtt == 'none' and back == 'none' and isfr == 'none':
liststrgvarb.append(strgvarb)
if gdat.booldiagmode:
for strgvarb in liststrgvarb:
if liststrgvarb.count(strgvarb) != 1:
print('liststrgvarb')
print(liststrgvarb)
print('popl')
print(popl)
print('ener')
print(ener)
print('evtt')
print(evtt)
print('back')
print(back)
print('isfr')
print(isfr)
print('iele')
print(iele)
raise Exception('')
return liststrgvarb
def setp_varb(gdat, strgvarbbase, valu=None, minm=None, maxm=None, scal='self', lablroot=None, lablunit='', mean=None, stdv=None, cmap=None, numbbins=10, \
popl='none', ener='none', evtt='none', back='none', isfr='none', iele='none', \
boolinvr=False, \
strgmodl=None, strgstat=None, \
):
'''
Set up variable values across all models (true and fitting) as well as all populations, energy bins,
event bins, background components, and Sersic components
'''
# determine the list of models
if strgmodl is None:
if gdat.typedata == 'mock':
liststrgmodl = ['true', 'fitt', 'plot']
else:
liststrgmodl = ['fitt', 'plot']
else:
if strgmodl == 'true' or strgmodl == 'plot' or strgmodl == 'refr':
liststrgmodl = [strgmodl]
else:
liststrgmodl = ['fitt', 'plot']
print('liststrgmodl')
print(liststrgmodl)
for strgmodl in liststrgmodl:
if strgmodl == 'plot':
gmod = gdat.fitt
gmodoutp = gdat
else:
gmod = getattr(gdat, strgmodl)
gmodoutp = gmod
# get the list of names of the variable
liststrgvarbnone = setp_namevarbsing(gdat, gmod, strgmodl, strgvarbbase, popl, ener, evtt, back, isfr, 'none')
if iele != 'none':
liststrgvarb = setp_namevarbsing(gdat, gmod, strgmodl, strgvarbbase, popl, ener, evtt, back, isfr, iele)
else:
liststrgvarb = liststrgvarbnone
# set the values of each variable in the list
for strgvarb in liststrgvarb:
if minm is not None:
setp_varbcore(gdat, strgmodl, gmodoutp.minmpara, strgvarb, minm)
if maxm is not None:
setp_varbcore(gdat, strgmodl, gmodoutp.maxmpara, strgvarb, maxm)
if mean is not None:
setp_varbcore(gdat, strgmodl, gmodoutp.meanpara, strgvarb, mean)
if stdv is not None:
setp_varbcore(gdat, strgmodl, gmodoutp.meanpara, strgvarb, stdv)
if valu is not None:
if strgstat is None:
print('strgvarb')
print(strgvarb)
print('strgmodl')
print(strgmodl)
print('valu')
print(valu)
print('')
setp_varbcore(gdat, strgmodl, gmodoutp, strgvarb, valu)
elif strgstat == 'this':
setp_varbcore(gdat, strgmodl, gmodoutp.this, strgvarb, valu)
if scal is not None:
setp_varbcore(gdat, strgmodl, gmodoutp.scalpara, strgvarb, scal)
if lablroot is not None:
setp_varbcore(gdat, strgmodl, gmodoutp.lablrootpara, strgvarb, lablroot)
if lablunit is not None:
setp_varbcore(gdat, strgmodl, gmodoutp.lablunitpara, strgvarb, lablunit)
if cmap is not None:
setp_varbcore(gdat, strgmodl, gmodoutp.cmappara, strgvarb, cmap)
setp_varbcore(gdat, strgmodl, gmodoutp.numbbinspara, strgvarb, numbbins)
# create limt, bins, mean, and delt
if minm is not None and maxm is not None or mean is not None and stdv is not None:
# determine minima and maxima for Gaussian or log-Gaussian distributed parameters
if mean is not None:
minm = mean - gdat.numbstdvgaus * stdv
maxm = mean + gdat.numbstdvgaus * stdv
# uniformly-distributed
if scal == 'self' or scal == 'pois' or scal == 'gaus':
binsunif = np.linspace(minm, maxm, numbbins + 1)
if scal == 'logt' or scal == 'powr':
binsunif = np.linspace(np.log10(minm), np.log10(maxm), numbbins + 1)
if gdat.booldiagmode:
if minm <= 0.:
raise Exception('')
if scal == 'asnh':
binsunif = np.linspace(np.arcsinh(minm), np.arcsinh(maxm), numbbins + 1)
if boolinvr:
binsunif = binsunif[::-1]
meanparaunif = (binsunif[1:] + binsunif[:-1]) / 2.
if scal == 'self' or scal == 'pois' or scal == 'gaus':
meanpara = meanparaunif
bins = binsunif
minmunif = minm
maxmunif = maxm
if scal == 'logt' or scal == 'powr':
meanpara = 10**meanparaunif
bins = 10**binsunif
minmunif = np.log10(minm)
maxmunif = np.log10(maxm)
if scal == 'asnh':
meanpara = np.sinh(meanparaunif)
bins = np.sinh(binsunif)
minmunif = np.arcsinh(minm)
maxmunif = np.arcsinh(maxm)
delt = np.diff(bins)
limt = np.array([minm, maxm])
# 'self' is not yet defined
if scal == 'asnh' or scal == 'logt' or scal == 'powr':
listvalutickmajr, listlabltickmajr, listvalutickminr, listlabltickminr = tdpy.retr_valulabltick(minm, maxm, scal)
setattr(gmodoutp.labltickmajrpara, strgvarb, listlabltickmajr)
setattr(gmodoutp.valutickmajrpara, strgvarb, listvalutickmajr)
setattr(gmodoutp.labltickminrpara, strgvarb, listlabltickminr)
setattr(gmodoutp.valutickminrpara, strgvarb, listvalutickminr)
#labltick = np.empty(gdat.numbtickcbar, dtype=object)
#for k in range(gdat.numbtickcbar):
# if scal == 'asnh':
# valutick[k] = np.sinh(tickunif[k])
# if scal == 'logt' or scal == 'powr':
# valutick[k] = 10**(tickunif[k])
# # avoid very small, but nonzero central values in the residual count color maps
# if strgcbar == 'cntpresi' and np.fabs(valutick[k]) < 1e-5:
# valutick[k] = 0.
# if strgcbar == 'cntpdata' and np.amax(valutick) > 1e3:
# labltick[k] = '%d' % valutick[k]
# else:
# labltick[k] = '%.3g' % valutick[k]
setattr(gmodoutp.limtpara, strgvarb, limt)
setattr(gmodoutp.binspara, strgvarb, bins)
setattr(gmodoutp.meanpara, strgvarb, meanpara)
setattr(gmodoutp.deltpara, strgvarb, delt)
def retr_ticklabltemp(gdat, strgcbar):
minm = getattr(gdat.minmpara, strgcbar)
maxm = getattr(gdat.maxmpara, strgcbar)
scal = getattr(gdat.scalpara, strgcbar)
numb = gdat.numbtickcbar - 1
retr_axis(gdat, strgcbar, numb=numb)
minmscal = minm
if scal == 'asnh':
minmscal = np.arcsinh(minmscal)
if scal == 'logt':
minmscal = np.log10(minmscal)
maxmscal = maxm
if scal == 'asnh':
maxmscal = np.arcsinh(maxmscal)
if scal == 'logt':
maxmscal = np.log10(maxmscal)
tickscal = np.linspace(minmscal, maxmscal, gdat.numbtickcbar)
labl = np.empty(gdat.numbtickcbar, dtype=object)
tick = np.copy(tickscal)
for k in range(gdat.numbtickcbar):
if scal == 'asnh':
tick[k] = np.sinh(tickscal[k])
elif scal == 'logt':
tick[k] = 10**(tickscal[k])
# avoid very small, but nonzero central values in the residual count color maps
if strgcbar == 'cntpresi' and np.fabs(tick[k]) < 1e-5:
tick[k] = 0.
if strgcbar == 'cntpdata' and np.amax(tick) > 1e3:
labl[k] = '%d' % tick[k]
else:
labl[k] = '%.3g' % tick[k]
setattr(gdat.tickpara, strgcbar, tick)
def retr_axistemp(gdat, strgvarb, strgmodl=None, boolinvr=False):
if strgmodl is None:
listgdattemp = [gdat]
for strgmodl in gdat.liststrgmodl:
listgdattemp.append(getattr(gdat, strgmodl))
elif strgmodl == 'fitt' or strgmodl == 'true':
listgdattemp = [getattr(gdat, strgmodl)]
elif strgmodl == 'allm':
listgdattemp = []
for strgmodl in gdat.liststrgmodl:
listgdattemp = getattr(gdat, strgmodl)
for gdattemp in listgdattemp:
minm = getattr(gdattemp.minmpara, strgvarb)
maxm = getattr(gdattemp.maxmpara, strgvarb)
numb = getattr(gdattemp.numbbinspara, strgvarb)
scal = getattr(gdattemp.scalpara, strgvarb)
if scal == 'self' or scal == 'pois' or scal == 'gaus':
binsscal = np.linspace(minm, maxm, numb + 1)
if scal == 'logt':
print('minm')
print(minm)
print('maxm')
print(maxm)
print('strgvarb')
print(strgvarb)
binsscal = np.linspace(np.log10(minm), np.log10(maxm), numb + 1)
print('')
if gdat.booldiagmode:
if minm <= 0.:
raise Exception('')
if scal == 'asnh':
binsscal = np.linspace(np.arcsinh(minm), np.arcsinh(maxm), numb + 1)
if boolinvr:
binsscal = binsscal[::-1]
meanvarbscal = (binsscal[1:] + binsscal[:-1]) / 2.
if scal == 'self' or scal == 'pois' or scal == 'gaus':
meanvarb = meanvarbscal
bins = binsscal
if scal == 'logt':
meanvarb = 10**meanvarbscal
bins = 10**binsscal
if scal == 'asnh':
meanvarb = np.sinh(meanvarbscal)
bins = np.sinh(binsscal)
delt = np.diff(bins)
limt = np.array([np.amin(bins), np.amax(bins)])
setattr(gdattemp.limtpara, strgvarb, limt)
setattr(gdattemp.binspara, strgvarb, bins)
setattr(gdattemp.meanpara, strgvarb, meanvarb)
setattr(gdattemp.deltpara, strgvarb, delt)
def setp_varbcore(gdat, strgmodl, gdattemp, strgvarbtemp, valu):
# check if the variable is defined by the user
try:
valutemp = getattr(gdattemp, strgvarbtemp)
if valutemp is None:
raise
if gdat.typeverb > 0:
print('Received custom value for %s, %s: %s' % (strgvarbtemp, strgmodl, valutemp))
# if not defined or defined as None, define it
except:
setattr(gdattemp, strgvarbtemp, valu)
def intp_sinc(gdat, lgal, bgal):
intpsinc = 4. * gdat.numbsidepsfn**2 * np.sum(gdat.temppsfn * sinc(gdat.numbsidepsfn * (gdat.gridpsfnlgal + lgal) - gdat.gridpsfnlgal) * \
sinc(gdat.numbsidepsfn * (gdat.gridpsfnbgal + bgal) - gdat.gridpsfnbgal))
return intpsinc
def retr_fluxbrgt(gdat, lgal, bgal, flux):
if lgal.size == 0:
fluxbrgt = np.array([0.])
fluxbrgtassc = np.array([0.])
else:
indxbrgt = np.argmax(flux)
fluxbrgt = flux[indxbrgt]
return fluxbrgt, fluxbrgtassc
def init_figr(gdat, gdatmodi, strgpdfn, strgplot, strgstat, strgmodl, indxenerplot, indxevttplot, indxpoplplot):
figrsize = (gdat.sizeimag, gdat.sizeimag)
figr, axis = plt.subplots(figsize=figrsize)
nameplot = strgplot
if gdat.numbener > 1:
nameplot += 'en%02d' % gdat.indxenerincl[indxenerplot]
if gdat.numbener > 1:
if indxevttplot == -1:
nameplot += 'evtA'
else:
nameplot += 'evt%d' % gdat.indxevttincl[indxevttplot]
if gdat.fitt.numbpopl > 1:
if indxpoplplot == -1:
nameplot += 'popA'
else:
nameplot += 'pop%d' % indxpoplplot
path = retr_plotpath(gdat, gdatmodi, strgpdfn, strgstat, strgmodl, nameplot)
print('gdat.fitt.labltotlpara.lgalpop0')
print(gdat.fitt.labltotlpara.lgalpop0)
print('gdat.fitt.labltotlpara.bgalpop0')
print(gdat.fitt.labltotlpara.bgalpop0)
axis.set_xlabel(gdat.fitt.labltotlpara.lgalpop0)
axis.set_ylabel(gdat.fitt.labltotlpara.bgalpop0)
titl = ''
if indxenerplot is not None and gdat.numbener > 1 and strgplot.endswith('cnts'):
titl = gdat.strgener[indxenerplot]
if indxevttplot is not None and gdat.numbevtt > 1 and strgplot.endswith('cnts'):
titl += ' ' + gdat.strgevtt[indxevttplot]
axis.set_title(titl)
return figr, axis, path
def draw_frambndr(gdat, axis):
outr = max(gdat.frambndrmodl, gdat.frambndrdata)
axis.set_xlim([-outr, outr])
axis.set_ylim([-outr, outr])
innr = min(gdat.frambndrmodl, gdat.frambndrdata)
axis.axvline(innr, ls='--', alpha=gdat.alphbndr, color='black')
axis.axvline(-innr, ls='--', alpha=gdat.alphbndr, color='black')
axis.axhline(innr, ls='--', alpha=gdat.alphbndr, color='black')
axis.axhline(-innr, ls='--', alpha=gdat.alphbndr, color='black')
def retr_imag(gdat, axis, maps, strgstat, strgmodl, strgcbar, indxenerplot=None, indxevttplot=-1, booltdim=False, imag=None):
draw_frambndr(gdat, axis)
# take the relevant energy and PSF bins
if indxenerplot is not None:
if indxevttplot == -1:
maps = np.sum(maps[indxenerplot, ...], axis=1)
else:
maps = maps[indxenerplot, :, indxevttplot]
# project the map to 2D
if gdat.typepixl == 'heal':
maps = tdpy.retr_cart(maps, indxpixlrofi=gdat.indxpixlrofi, numbsideinpt=gdat.numbsideheal, \
minmlgal=gdat.anglfact*gdat.minmlgaldata, maxmlgal=gdat.anglfact*gdat.maxmlgaldata, \
minmbgal=gdat.anglfact*gdat.minmbgaldata, maxmbgal=gdat.anglfact*gdat.maxmbgaldata)
if gdat.typepixl == 'cart':
shap = [gdat.numbsidecart] + list(maps.shape)
shap[1] = gdat.numbsidecart
shapflat = list(maps.shape)
shapflat[0] = gdat.numbpixlfull
mapstemp = np.zeros(shapflat)
if maps.size == gdat.indxpixlrofi.size:
mapstemp[gdat.indxpixlrofi, ...] = maps
else:
mapstemp[:, ...] = maps
maps = mapstemp.reshape(shap).swapaxes(0, 1)
# temp -- this is needed to bring the Fermi-LAT map to the right direction
#maps = fliplr(maps)
# rescale the map
if strgmodl is not None:
gmod = getattr(gdat, strgmodl)
else:
gmod = gdat
scal = getattr(gdat.scalpara, strgcbar)
cmap = getattr(gdat.cmappara, strgcbar)
vmin = getattr(gdat.minmpara, strgcbar)
vmax = getattr(gdat.maxmpara, strgcbar)
if scal == 'asnh':
maps = np.arcsinh(maps)
if scal == 'logt':
maps = np.log10(maps)
if imag is None:
imag = axis.imshow(maps, cmap=cmap, origin='lower', extent=gdat.exttrofi, interpolation='nearest', vmin=vmin, vmax=vmax, alpha=gdat.alphmaps)
return imag
else:
imag.set_data(maps)
def make_cbar(gdat, axis, imag, strgvarb):
# make a color bar
valutickmajr = getattr(gdat.valutickmajrpara, strgvarb)
labltickmajr = getattr(gdat.labltickmajrpara, strgvarb)
print('valutickmajr')
print(valutickmajr)
print('labltickmajr')
print(labltickmajr)
cbar = plt.colorbar(imag, ax=axis, fraction=0.05, aspect=15)
cbar.set_ticks(valutickmajr)
cbar.set_ticklabels(labltickmajr)
return cbar
def make_legdmaps(gdat, strgstat, strgmodl, axis, mosa=False, assc=False):
gmod = getattr(gdat, strgmodl)
# transdimensional elements
if strgmodl == 'fitt' and (strgstat == 'pdfn' and gdat.boolcondcatl or strgstat == 'this') and gmod.numbparaelem > 0:
for l in gmod.indxpopl:
colr = retr_colr(gdat, strgstat, strgmodl, l)
if strgstat == 'pdfn':
labl = 'Condensed %s %s' % (gmod.legd, gmod.legdpopl[l])
else:
labl = 'Sample %s %s' % (gmod.legd, gmod.legdpopl[l])
if not gmod.maxmpara.numbelem[l] == 0:
axis.scatter(gdat.anglfact * gdat.maxmgangdata * 5., gdat.anglfact * gdat.maxmgangdata * 5, s=50, alpha=gdat.alphelem, \
label=labl, marker=gmod.listelemmrkr[l], lw=gdat.mrkrlinewdth, color=colr)
for q in gdat.indxrefr:
if not np.amax(gdat.refr.numbelem[q]) == 0:
if assc:
axis.scatter(gdat.anglfact * gdat.maxmgangdata * 5., gdat.anglfact * gdat.maxmgangdata * 5, s=50, alpha=gdat.alphelem, \
label=gdat.refr.lablhits[q], marker=gdat.refr.listmrkrhits[q], lw=gdat.mrkrlinewdth, color=gdat.refr.colrelem[q])
axis.scatter(gdat.anglfact * gdat.maxmgangdata * 5., gdat.anglfact * gdat.maxmgangdata * 5, s=50, alpha=gdat.alphelem, facecolor='none', \
label=gdat.refr.lablmiss[q], marker=gdat.refr.listmrkrmiss[q], lw=gdat.mrkrlinewdth, color=gdat.refr.colrelem[q])
else:
axis.scatter(gdat.anglfact * gdat.maxmgangdata * 5., gdat.anglfact * gdat.maxmgangdata * 5, s=50, alpha=gdat.alphelem, facecolor='none', \
label=gdat.refr.lablelem[q], marker=gdat.refr.listmrkrmiss[q], lw=gdat.mrkrlinewdth, color=gdat.refr.colrelem[q])
# fixed-dimensional objects
if strgmodl == 'fitt':
if gmod.boollens:
axis.scatter(gdat.anglfact * gdat.maxmgangdata * 5., gdat.anglfact * gdat.maxmgangdata * 5, s=50, alpha=gdat.alphelem, facecolor='none', \
label='%s Source' % gmod.lablmodl, marker='<', lw=gdat.mrkrlinewdth, color=gmod.colr)
if gmod.typeemishost != 'none':
axis.scatter(gdat.anglfact * gdat.maxmgangdata * 5., gdat.anglfact * gdat.maxmgangdata * 5, s=50, alpha=gdat.alphelem, facecolor='none', \
label='%s Host' % gmod.lablmodl, marker='s', lw=gdat.mrkrlinewdth, color=gmod.colr)
if gdat.typedata == 'mock':
if gmod.boollens:
axis.scatter(gdat.anglfact * gdat.maxmgangdata * 5., gdat.anglfact * gdat.maxmgangdata * 5, s=50, alpha=gdat.alphelem, facecolor='none', \
label='%s Source' % gdat.refr.labl, marker='>', lw=gdat.mrkrlinewdth, color=gdat.refr.colr)
if gmod.typeemishost != 'none':
axis.scatter(gdat.anglfact * gdat.maxmgangdata * 5., gdat.anglfact * gdat.maxmgangdata * 5, s=50, alpha=gdat.alphelem, facecolor='none', \
label='%s Host' % gdat.refr.labl, marker='D', lw=gdat.mrkrlinewdth, color=gdat.refr.colr)
temphand, temp = axis.get_legend_handles_labels()
numblabl = len(temp)
if numblabl == 4:
numbcols = 2
else:
numbcols = 3
if mosa:
axis.legend(bbox_to_anchor=[1., 1.15], loc='center', ncol=numbcols)
else:
axis.legend(bbox_to_anchor=[0.5, 1.15], loc='center', ncol=numbcols)
def supr_fram(gdat, gdatmodi, strgstat, strgmodl, axis, indxpoplplot=-1, assc=False):
gmod = getattr(gdat, strgmodl)
gmodstat = getattr(gmod, strgstat)
# associations with the reference elements
for q in gdat.indxrefr:
if gdat.refr.numbelem[q] > 0:
if indxpoplplot == -1:
listindxpoplplot = gmod.indxpopl
else:
listindxpoplplot = [indxpoplplot]
for l in listindxpoplplot:
reframpl = gdat.refr.dictelem[q][gdat.refr.nameparagenrelemampl[q]][0, :]
mrkrsize = retr_mrkrsize(gdat, strgmodl, reframpl, gdat.refr.nameparagenrelemampl[q])
lgal = np.copy(gdat.refr.dictelem[q]['lgal'][0, :])
bgal = np.copy(gdat.refr.dictelem[q]['bgal'][0, :])
numbelem = int(gdat.refr.numbelem[q])
if gdatmodi is not None and gmod.numbparaelem > 0 and assc:
### hit
indx = gdatmodi.this.indxelemrefrasschits[q][l]
if indx.size > 0:
axis.scatter(gdat.anglfact * lgal[indx], gdat.anglfact * bgal[indx], s=mrkrsize[indx], alpha=gdat.alphelem, label=gdat.refr.lablhits, \
marker=gdat.refrlistmrkrhits[q], lw=gdat.mrkrlinewdth, color=gdat.refr.colrelem[q])
### missed
indx = gdatmodi.this.indxelemrefrasscmiss[q][l]
else:
indx = np.arange(lgal.size)
if indx.size > 0:
axis.scatter(gdat.anglfact * lgal[indx], gdat.anglfact * bgal[indx], s=mrkrsize[indx], alpha=gdat.alphelem, facecolor='none', \
label=gdat.refr.listlablmiss, marker=gdat.refr.listmrkrmiss[q], \
lw=gdat.mrkrlinewdth, color=gdat.refr.colrelem[q])
sizexoff = gdat.maxmgangdata * 0.05 * gdat.anglfact
sizeyoff = gdat.maxmgangdata * 0.05 * gdat.anglfact
if 'etag' in gdat.refr.namepara.elem[q]:
for k in range(indx.size):
axis.text(gdat.anglfact * lgal[indx[k]] + sizexoff, gdat.anglfact * bgal[indx[k]] + sizeyoff, gdat.refretag[q][indx[k]], \
verticalalignment='center', horizontalalignment='center', \
color='red', fontsize=1)
# temp -- generalize this to input refrlgalhost vs.
if gdat.typedata == 'mock':
## host galaxy position
if gmod.typeemishost != 'none':
for e in gmod.indxsersfgrd:
lgalhost = gmodstat.paragenrscalfull[getattr(gmod.indxpara, 'lgalhostisf%d' % (e))]
bgalhost = gmodstat.paragenrscalfull[getattr(gmod.indxpara, 'bgalhostisf%d' % (e))]
axis.scatter(gdat.anglfact * lgalhost, gdat.anglfact * bgalhost, facecolor='none', alpha=0.7, \
label='%s Host %d' % (gdat.refr.labl, e), s=300, marker='D', lw=gdat.mrkrlinewdth, color=gdat.refr.colr)
if gmod.boollens:
## host galaxy Einstein radius
for e in gmod.indxsersfgrd:
truelgalhost = gmodstat.paragenrscalfull[getattr(gmod.indxpara, 'lgalhostisf%d' % (e))]
truebgalhost = gmodstat.paragenrscalfull[getattr(gmod.indxpara, 'bgalhostisf%d' % (e))]
truebeinhost = gmodstat.paragenrscalfull[getattr(gmod.indxpara, 'beinhostisf%d' % (e))]
axis.add_patch(plt.Circle((gdat.anglfact * truelgalhost, \
gdat.anglfact * truebgalhost), \
gdat.anglfact * truebeinhost, \
edgecolor=gdat.refr.colr, facecolor='none', lw=gdat.mrkrlinewdth))
if gmod.boollens:
## source galaxy position
axis.scatter(gdat.anglfact * gmodstat.paragenrscalfull[gmod.indxpara.lgalsour], \
gdat.anglfact * gmodstat.paragenrscalfull[gmod.indxpara.bgalsour], \
facecolor='none', \
alpha=0.7, \
#alpha=gdat.alphelem, \
label='%s Source' % gdat.refr.labl, s=300, marker='>', lw=gdat.mrkrlinewdth, color=gdat.refr.colr)
# model catalog
if indxpoplplot == -1:
listindxpoplplot = gmod.indxpopl
else:
listindxpoplplot = [indxpoplplot]
for l in listindxpoplplot:
if gdatmodi is not None:
if gmod.numbparaelem > 0:
colr = retr_colr(gdat, strgstat, strgmodl, l)
mrkrsize = retr_mrkrsize(gdat, strgmodl, gdatmodi.this.paragenrscalfull[gdatmodi.this.indxparagenrfullelem[gmod.nameparagenrelemampl[l]][l]], gmod.nameparagenrelemampl[l])
if 'lgal' in gdatmodi.this.indxparagenrfullelem:
lgal = gdatmodi.this.paragenrscalfull[gdatmodi.this.indxparagenrfullelem[l]['lgal']]
bgal = gdatmodi.this.paragenrscalfull[gdatmodi.this.indxparagenrfullelem[l]['bgal']]
else:
gang = gdatmodi.this.paragenrscalfull[gdatmodi.this.indxparagenrfullelem[l]['gang']]
aang = gdatmodi.this.paragenrscalfull[gdatmodi.this.indxparagenrfullelem[l]['aang']]
lgal, bgal = retr_lgalbgal(gang, aang)
axis.scatter(gdat.anglfact * lgal, gdat.anglfact * bgal, s=mrkrsize, alpha=gdat.alphelem, label='Sample', marker=gmod.listelemmrkr[l], \
lw=gdat.mrkrlinewdth, color=colr)
## source
if gmod.boollens:
lgalsour = gdatmodi.this.paragenrscalfull[gmod.indxpara.lgalsour]
bgalsour = gdatmodi.this.paragenrscalfull[gmod.indxpara.bgalsour]
axis.scatter(gdat.anglfact * lgalsour, gdat.anglfact * bgalsour, facecolor='none', \
alpha=gdat.alphelem, \
label='%s Source' % gmod.lablpara, s=300, marker='<', lw=gdat.mrkrlinewdth, color=gmod.colr)
if gmod.typeemishost != 'none':
## host
lgalhost = [[] for e in gmod.indxsersfgrd]
bgalhost = [[] for e in gmod.indxsersfgrd]
for e in gmod.indxsersfgrd:
lgalhost[e] = gdatmodi.this.paragenrscalfull[getattr(gmod.indxpara, 'lgalhostisf%d' % (e))]
bgalhost[e] = gdatmodi.this.paragenrscalfull[getattr(gmod.indxpara, 'bgalhostisf%d' % (e))]
axis.scatter(gdat.anglfact * lgalhost[e], gdat.anglfact * bgalhost[e], facecolor='none', \
alpha=gdat.alphelem, \
label='%s Host' % gmod.lablpara, s=300, marker='s', lw=gdat.mrkrlinewdth, color=gmod.colr)
if gmod.boollens:
beinhost = gdatmodi.this.paragenrscalfull[getattr(gmod.indxpara, 'beinhostisf%d' % (e))]
axis.add_patch(plt.Circle((gdat.anglfact * lgalhost[e], gdat.anglfact * bgalhost[e]), \
gdat.anglfact * beinhost, edgecolor=gmod.colr, facecolor='none', \
lw=gdat.mrkrlinewdth, ls='--'))
# temp
if strgstat == 'pdfn' and gdat.boolcondcatl and gmod.numbparaelem > 0:
lgal = np.zeros(gdat.numbprvlhigh)
bgal = np.zeros(gdat.numbprvlhigh)
ampl = np.zeros(gdat.numbprvlhigh)
cntr = 0
for r in gdat.indxstkscond:
if r in gdat.indxprvlhigh:
lgal[cntr] = gdat.dictglob['poststkscond'][r]['lgal'][0]
bgal[cntr] = gdat.dictglob['poststkscond'][r]['bgal'][0]
# temp -- this does not allow sources with different spectra to be assigned to the same stacked sample
ampl[cntr] = gdat.dictglob['poststkscond'][r][gmod.nameparagenrelemampl[l]][0]
cntr += 1
mrkrsize = retr_mrkrsize(gdat, strgmodl, ampl, gmod.nameparagenrelemampl[l])
colr = retr_colr(gdat, strgstat, strgmodl, l)
axis.scatter(gdat.anglfact * lgal, gdat.anglfact * bgal, s=mrkrsize, \
label='Condensed', marker=gmod.listelemmrkr[l], color='black', lw=gdat.mrkrlinewdth)
for r in gdat.indxstkscond:
lgal = np.array([gdat.dictglob['liststkscond'][r]['lgal']])
bgal = np.array([gdat.dictglob['liststkscond'][r]['bgal']])
axis.scatter(gdat.anglfact * lgal, gdat.anglfact * bgal, s=mrkrsize, \
marker=gmod.listelemmrkr[l], color='black', alpha=0.1, lw=gdat.mrkrlinewdth)
def retr_colr(gdat, strgstat, strgmodl, indxpopl=None):
if strgmodl == 'true':
if indxpopl is None:
colr = gdat.refr.colr
else:
colr = gdat.refr.colrelem[indxpopl]
if strgmodl == 'fitt':
if strgstat == 'this' or strgstat == 'pdfn':
if indxpopl is None:
colr = gmod.colr
else:
colr = gmod.colrelem[indxpopl]
if strgstat == 'mlik':
colr = 'r'
return colr
def retr_levipost(listllik):
minmlistllik = np.amin(listllik)
levipost = np.log(np.mean(1. / np.exp(listllik - minmlistllik))) + minmlistllik
return levipost
def retr_infofromlevi(pmeallik, levi):
info = pmeallik - levi
return info
def retr_jcbn():
fluxpare, lgalpare, bgalpare, fluxauxi, lgalauxi, bgalauxi = sympy.symbols('fluxpare lgalpare bgalpare fluxauxi lgalauxi bgalauxi')
matr = sympy.Matrix([[ fluxpare, fluxauxi, 0, 0, 0, 0], \
[-fluxpare, 1 - fluxauxi, 0, 0, 0, 0], \
[-lgalauxi, 0, 1, 1 - fluxauxi, 0, 0], \
[-lgalauxi, 0, 1, -fluxauxi, 0, 0], \
[-bgalauxi, 0, 0, 0, 1, 1 - fluxauxi], \
[-bgalauxi, 0, 0, 0, 1, -fluxauxi]])
jcbn = matr.det()
return jcbn
# f1 = uf f0
# f2 = (1 - uf) f0
# x1 = x0 + (1 - uf) ux
# x2 = x0 - uf ux
# y1 = y0 + (1 - uf) uy
# y2 = y0 - uf uy
# f1/uf f1/f0 f1/x0 f1/ux f1/y0 f1/uy
# f2/uf f2/f0 f2/x0 f2/ux f2/y0 f2/uy
# x1/uf x1/f0 x1/x0 x1/ux x1/y0 x1/uy
# x2/uf x2/f0 x2/x0 x2/ux x2/y0 x2/uy
# y1/uf y1/f0 y1/x0 y1/ux y1/y0 y1/uy
# y2/uf y2/f0 y2/x0 y2/ux y2/y0 y2/uy
# f0 uf 0 0 0 0
# -f0 1 - uf 0 0 0 0
# -ux 0 1 1 - uf 0 0
# -ux 0 1 -uf 0 0
# -uy 0 0 0 1 1 - uf
# -uy 0 0 0 1 -uf
# f0
#retr_jcbn()
def retr_angldist(gdat, lgalfrst, bgalfrst, lgalseco, bgalseco):
# temp -- heal does not work when the dimension of lgalfrst is 1
if gdat.typepixl == 'heal':
dir1 = np.array([lgalfrst, bgalfrst])
dir2 = np.array([lgalseco, bgalseco])
angldist = hp.rotator.angdist(dir1, dir2)
else:
angldist = np.sqrt((lgalfrst - lgalseco)**2 + (bgalfrst - bgalseco)**2)
return angldist
def retr_deflextr(gdat, indxpixlelem, sher, sang):
factcosi = sher * np.cos(2. * sang)
factsine = sher * np.cos(2. * sang)
defllgal = factcosi * gdat.lgalgrid[indxpixlelem] + factsine * gdat.bgalgrid[indxpixlelem]
deflbgal = factsine * gdat.lgalgrid[indxpixlelem] - factcosi * gdat.bgalgrid[indxpixlelem]
return np.vstack((defllgal, deflbgal)).T
def readfile(path):
print('Reading %s...' % path)
filepick = open(path + '.p', 'rb')
filearry = h5py.File(path + '.h5', 'r')
gdattemptemp = pickle.load(filepick)
for attr in filearry:
setattr(gdattemptemp, attr, filearry[attr][()])
filepick.close()
filearry.close()
if 'gdatfinl' in path or 'gdatinit' in path:
if hasattr(gdattemptemp, 'edis') and gdattemptemp.edis is not None and hasattr(gdattemptemp, 'binsener'):
gdattemptemp.edisintp = sp.interpolate.interp1d(gdattemptemp.binsener, gdattemptemp.edis, fill_value='extrapolate')
gdattemptemp.adisobjt = sp.interpolate.interp1d(gdattemptemp.redsintp, gdattemptemp.adisintp, fill_value='extrapolate')
gdattemptemp.redsfromdlosobjt = sp.interpolate.interp1d(gdattemptemp.adisintp * gdattemptemp.redsintp, \
gdattemptemp.redsintp, fill_value='extrapolate')
return gdattemptemp
def init_stat(gdat):
# construct the initial state
if gdat.typeverb > 0:
print('Initializing the sampler state...')
print('inittype')
print(gdat.inittype)
gmod = gdat.fitt
## initialization
### initialize the unit sample vector randomly
gmod.this.paragenrunitfull = np.random.rand(gmod.numbparagenrfull)
gmod.this.paragenrscalfull = np.empty(gmod.numbparagenrfull)
## impose user-specified initial state
### number of elements
## create dummy indxparagenrfullelem
gmod.this.indxparagenrfullelem = None
if gmod.numbparaelem > 0:
if gdat.inittype == 'refr':
for l in gmod.indxpopl:
gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]] = gmod.paragenrunitfull[gmod.indxpara.numbelem[l]]
else:
for l in gmod.indxpopl:
if gmod.typemodltran == 'pois':
meanelemtemp = icdf_paragenrscalfull(gdat, 'fitt', gmod.this.paragenrunitfull, \
gmod.this.indxparagenrfullelem)[gmod.indxpara.meanelem[l]]
print('temp -- user input is not working for numbelem')
#namevarb = 'numbelempop%d' % l
#initvalu = getattr(gmod.init, namevarb)
#if initvalu > gmod.maxmpara.numbelem[l] or initvalu < gmod.minmpara.numbelem[l]:
# raise Exception('Bad initial number of elements...')
#gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]] = initvalu
if gmod.typemodltran == 'pois':
gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]] = np.random.poisson(meanelemtemp)
gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]] = round(gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]])
gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]] = \
min(gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]], gmod.maxmpara.numbelem[l])
gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]] = \
max(gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]], gmod.minmpara.numbelem[l])
gmod.this.paragenrscalfull[gmod.indxpara.numbelem[l]] = gmod.this.paragenrscalfull[gmod.indxpara.numbelem[l]]
if gdat.booldiagmode:
if gdat.typedata == 'mock' and gdat.inittype == 'refr':
for l in gmod.indxpopl:
if gmod.paragenrunitfull[gmod.indxpara.numbelem[l]] > gmod.maxmpara.numbelem[l]:
raise Exception('')
if gmod.numbparaelem > 0:
gmod.this.indxelemfull = []
for l in gmod.indxpopl:
gmod.this.indxelemfull.append(list(range(gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]].astype(int))))
gmod.this.indxparagenrfullelem = retr_indxparagenrfullelem(gdat, gmod.this.indxelemfull, 'fitt')
if gdat.inittype == 'reco':
if gdat.namerecostat is not None:
strgcnfg = gdat.namerecostat
else:
strgcnfg = gdat.strgcnfg
path = gdat.pathoutp + 'stat_' + strgcnfg + '.h5'
if os.path.exists(path):
boolinitreco = True
thisfile = h5py.File(path, 'r')
if gdat.typeverb > 0:
print('Initializing from the state %s...' % path)
print('Likelihood:')
print(thisfile['lliktotl'][...])
# find the number of populations provided
maxmindxpopl = 0
for l in range(10):
for attr in thisfile:
if attr.startswith('lgalpop'):
gmod.indxpopl = int(attr[7])
if gmod.indxpopl > maxmindxpopl:
maxmindxpopl = gmod.indxpopl
numbpoplinpt = maxmindxpopl + 1
if numbpoplinpt != gmod.numbpopl:
print('State file and fitting metamodel have different number of populations.')
# find the number of elements provided
cntr = np.zeros(gmod.numbpoplinpt, dtype=int)
for attr in thisfile:
if attr.startswith('lgalpop'):
gmod.indxpopl = int(attr[7])
cntr[indxpopl] += 1
if gdat.typeverb > 0:
print('Number of elements found:')
print(cntr)
for attr in thisfile:
for k, gmod.nameparagenrbase in enumerate(gmod.nameparagenrbase):
if gmod.nameparagenrbase == attr:
if gmod.nameparagenrbase.startswith('numbelem'):
try:
indxpopltemp = int(gmod.nameparagenrbase[-1])
initnumbelem = getattr(gdat, 'initnumbelempop%d' % indxpopltemp)
print('Initial condition for the number of elements conflicts with the state file. Defaulting to the argument...')
except:
initnumbelem = thisfile[attr][()]
gmod.this.paragenrunitfull[k] = initnumbelem
else:
gmod.this.paragenrunitfull[k] = cdfn_paragenrscalbase(gdat.fitt, '', thisfile[attr][()], k)
if gmod.this.paragenrunitfull[k] == 0.:
print('Warning CDF is zero.')
if not np.isfinite(thisfile[attr][()]):
raise Exception('Retreived state parameter is not finite.')
if (gmod.numbparaelem == 0 or gmod.numbparaelem > 0 and not k in gmod.indxpara.numbelem) and \
(not np.isfinite(gmod.this.paragenrunitfull[k]) or gmod.this.paragenrunitfull[k] < 0. or \
gmod.this.paragenrunitfull[k] > 1.):
raise Exception('CDF of the retreived state parameter is bad.')
if gmod.numbparaelem > 0:
for l in gmod.indxpopl:
maxm.numbelem = getattr(gdat.fitt.maxm, 'numbelempop%d' % l)
if gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]] > maxm.numbelem:
gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]] = maxm.numbelem
if gdat.typeverb > 0:
print('Tapering off the element list...')
gmod.this.indxelemfull = []
for l in gmod.indxpopl:
gmod.this.indxelemfull.append(list(range(gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]].astype(int))))
if gdat.typeverb > 0:
print('gmod.this.paragenrunitfull[gmod.indxpara.numbelem]')
print(gmod.this.paragenrunitfull[gmod.indxpara.numbelem])
gmod.this.indxparagenrfullelem = retr_indxparagenrfullelem(gdat, gmod.this.indxelemfull, 'fitt')
gmod.this.paragenrscalfull = icdf_paragenrscalfull(gdat, 'fitt', gmod.this.paragenrunitfull, gmod.this.indxparagenrfullelem)
if (gmod.this.paragenrunitfull == 0).all():
raise Exception('Bad initialization.')
if gmod.numbparaelem > 0 and gmod.this.indxparagenrfullelem is not None:
for nameparagenrelem in gmod.namepara.elem:
initcomp = [[] for l in gmod.indxpopl]
for l in gmod.indxpopl:
initcomp[l] = np.empty(len(gmod.this.indxelemfull[l]))
for k in range(len(gmod.this.indxelemfull[l])):
namefiel = '%spop%d%04d' % (nameparagenrelem, l, k)
for attr in thisfile:
if namefiel == attr:
initcomp[l][k] = thisfile[namefiel][()]
setattr(gdat, 'init' + nameparagenrelem, initcomp)
initcompfromstat(gdat, gdatmodi, 'init')
thisfile.close()
else:
boolinitreco = False
if gdat.typeverb > 0:
print('Could not find the state file, %s, to initialize the sampler.' % path)
if gdat.inittype == 'refr':
if gdat.typedata == 'inpt':
for l in gmod.indxpopl:
gmod.this.paragenrunitfull[gmod.indxpara.numbelem[l]] = gdat.refr.numbelem[l]
if gdat.typedata == 'mock':
for k, gmod.nameparagenrbase in enumerate(gmod.nameparagenrbase):
if not (gdat.inittype == 'pert' and gmod.nameparagenrbase.startswith('numbelem')) and \
gmod.nameparagenrbase in gmod.nameparagenrbase:
gmod.indxpara.true = np.where(gmod.nameparagenrbase == gmod.nameparagenrbase)[0]
gmod.this.paragenrunitfull[k] = cdfn_paragenrscalbase(gdat.fitt, '', gmodstat.paragenrscalfull[gmod.indxpara.true], k)
if gmod.numbparaelem > 0:
gmod.this.indxparagenrfullelem = retr_indxparagenrfullelem(gdat, gmod.this.indxelemfull, 'fitt')
if gdat.typeverb > 1:
show_paragenrscalfull(gdat, gdatmodi)
if gmod.this.indxparagenrfullelem is not None:
print('Initializing elements from the reference element parameters...')
show_paragenrscalfull(gdat, gdatmodi)
gmod.this.paragenrscalfull = icdf_paragenrscalfull(gdat, 'fitt', gmod.this.paragenrunitfull, gmod.this.indxparagenrfullelem)
show_paragenrscalfull(gdat, gdatmodi)
initcompfromstat(gdat, gdatmodi, 'refr')
gmod.this.paragenrscalfull = icdf_paragenrscalfull(gdat, 'fitt', gmod.this.paragenrunitfull, gmod.this.indxparagenrfullelem)
## impose user-specified individual initial values
for k, gmod.nameparagenrbase in enumerate(gmod.nameparagenrbase):
if gmod.nameparagenrbase.startswith('numbelem'):
continue
if gdat.inittype == 'reco' or gdat.inittype == 'refr' or gdat.inittype == 'pert':
try:
getattr(gdat, 'init' + gmod.nameparagenrbase)
print('Conflicting initial state arguments detected, init keyword takes precedence.')
except:
pass
try:
raise Exception('')
initvalu = getattr(gdat, 'init' + gmod.nameparagenrbase)
gmod.this.paragenrunitfull[k] = cdfn_paragenrscalbase(gdat.fitt, '', initvalu, k)
if gdat.typeverb > 0:
print('Received initial condition for %s: %.3g' % (gmod.nameparagenrbase, initvalu))
except:
pass
## PSF
if gdat.initpsfp is not None:
print('Initializing the metamodel PSF from the provided initial state...')
if gdat.initpsfp.size != gmod.indxpara.psfp.size:
raise Exception('')
for k, gmod.nameparagenrbase in enumerate(gmod.nameparagenrbase):
if k in gmod.indxpara.psfp:
gmod.this.paragenrunitfull[k] = cdfn_paragenrscalbase(gdat.fitt, '', gdat.initpsfp[k-gmod.indxpara.psfp[0]], k)
if gdat.initpsfprefr:
print('Initializing the metamodel PSF from the reference state...')
for k, gmod.nameparagenrbase in enumerate(gmod.nameparagenrbase):
if k in gmod.indxpara.psfp:
gmod.this.paragenrunitfull[k] = cdfn_paragenrscalbase(gdat.fitt, '', gmod.psfpexpr[k-gmod.indxpara.psfp[0]], k)
if gdat.inittype == 'rand' or gdat.inittype == 'reco' and not boolinitreco:
if gdat.typeverb > 0:
print('Initializing from a random state...')
gmod.this.paragenrscalfull = icdf_paragenrscalfull(gdat, 'fitt', gmod.this.paragenrunitfull, gmod.this.indxparagenrfullelem)
if gmod.numbparaelem > 0:
gmod.this.indxparagenrfullelem = retr_indxparagenrfullelem(gdat, gmod.this.indxelemfull, 'fitt')
# check the initial unit sample vector for bad entries
if gmod.numbparaelem > 0:
indxsampdiff = np.setdiff1d(gmod.indxparagenrfull, gmod.indxpara.numbelem)
if np.logical_not(np.isfinite(gmod.this.paragenrunitfull[indxsampdiff])).any():
raise Exception('')
indxsampbaddlowr = np.where((gmod.this.paragenrunitfull[indxsampdiff] <= 0.) | np.logical_not(np.isfinite(gmod.this.paragenrunitfull[indxsampdiff])))[0]
indxsampbadduppr = np.where(gmod.this.paragenrunitfull[indxsampdiff] >= 1.)[0]
indxsampbaddlowr = indxsampdiff[indxsampbaddlowr]
indxsampbadduppr = indxsampdiff[indxsampbadduppr]
else:
indxsampbaddlowr = np.where(gmod.this.paragenrunitfull <= 0.)[0]
indxsampbadduppr = np.where(gmod.this.paragenrunitfull >= 1.)[0]
indxsampbadd = np.concatenate((indxsampbaddlowr, indxsampbadduppr))
if indxsampbadd.size > 0:
print('Initial value caused unit sample vector to go outside the unit interval...')
show_paragenrscalfull(gdat, gdatmodi, indxsampshow=indxsampbadd)
gmod.this.paragenrunitfull[indxsampbadd] = np.random.rand(indxsampbadd.size)
raise Exception('')
gmod.this.paragenrscalfull = icdf_paragenrscalfull(gdat, 'fitt', gmod.this.paragenrunitfull, gmod.this.indxparagenrfullelem)
indxbadd = np.where(np.logical_not( | np.isfinite(gmod.this.paragenrscalfull) | numpy.isfinite |
import argparse
import SimpleITK as sitk
import skimage
import nibabel as ni
import numpy as np
import matplotlib.pyplot as plt
import skimage.measure
from pathlib import Path
def isocont(img_arr,
mask_arr,
b_out_labeled_mask=False,
b_class_components=True,
b_use_percentile_threshold=True,
percentile_threshold=25,
maximum_threshold=10,
verbose=True):
"""
Computes a mask based on percentile/relative maximum SUV value thresholds inside all
connected components of the original mask.
Args:
img_arr: array of a PET-SUV image.
mask_arr: array of a tumor mask.
b_out_labeled_mask: Output labeled component mask, no thresholding.
b_class_components: Detected connected components and use component based threshold.
b_use_percentile_threshold: Use percentile based thresholds (otherwise relative maximum value thresholds
are used.
percentile_threshold: Set percentile (SUV value) threshold in percent.
maximum_threshold: Set relative maximum (SUV value) threshold.
verbose:
Returns: array of the new mask.
"""
maximum_threshold = float(maximum_threshold)
# Get numpy array from sitk objects.
# amask = sitk.GetArrayFromImage(mask)
# animg = sitk.GetArrayFromImage(img)
amask = mask_arr
animg = img_arr
# Classify connected image components
if b_class_components:
amask_comp, num_comp = skimage.measure.label(amask,
neighbors=None,
background=None,
return_num=True,
connectivity=None)
else:
amask_comp = amask
num_comp = 1
print(f'Detected {num_comp} connected components.')
# Create new mask based on the selected threshold.
amask_th = np.zeros_like(amask)
# Calculate SUV value thresholds for each connected component.
for comp in range(num_comp):
if verbose:
print(f'Component {comp}')
sel_comp = (amask_comp == (comp + 1))
# Get SUV values inside the selected component.
suv_values = animg[sel_comp]
suv_max = np.max(suv_values)
if verbose:
print(f'#SUV values {suv_values.shape}')
print(f'Max. SUV value: {np.max(suv_values)}')
print(f'{percentile_threshold} percentile SUV value threshold {np.percentile(suv_values, percentile_threshold)}')
print(f'Relative max. SUV value threshold ({maximum_threshold}%): {suv_max * maximum_threshold/100.0}')
if b_use_percentile_threshold:
th = | np.percentile(suv_values, percentile_threshold) | numpy.percentile |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat May 29 18:13:24 2021
@author: tae-jun_yoon
"""
import numpy as np
from scipy.signal import savgol_filter
from scipy.optimize import newton
from PyOECP import References
def ListReferences():
AvailableReferences = dir(References)
for EachReference in AvailableReferences:
if '_' in EachReference and '__' not in EachReference:
print(EachReference)
def ReferenceDetail(ReferenceName):
from pprint import pprint
''' Print out detailed information about the reference spectra.
The Reference_name should be "string".
'''
import matplotlib.pyplot as plt
plt.figure(figsize=(5,5),dpi=250)
frequency = np.array([1e9])
data = eval('References.'+ReferenceName)(frequency)
minimum_frequency = data['minFREQ']
maximum_frequency = data['maxFREQ']
frequency = np.logspace(np.log10(minimum_frequency),np.log10(maximum_frequency),100)
data = eval('References.'+ReferenceName)(frequency)
epsilon = data['epsilon']
plt.semilogx(frequency,np.real(epsilon),'r')
plt.semilogx(frequency,- | np.imag(epsilon) | numpy.imag |
import trimesh
from trimesh.base import Trimesh
import trimesh.creation
from trimesh.remesh import subdivide_to_size
import matplotlib.tri as mtri
import numpy as np
import torch
import quaternion
import os
from tqdm import tqdm_notebook as tqdm
from matplotlib import pyplot as plt
def plot_info(history_grad_norm, history_quad_loss,
history_smooth_loss, history_loss,
history_p_deviation, history_p_deviation_target,
history_p_deviation_mean, history_p_deviation_target_mean):
plt.figure(figsize=(10, 8))
plt.semilogy(history_grad_norm)
plt.title('Grad norm')
plt.show()
plt.figure(figsize=(10, 8))
plt.semilogy(np.array(history_quad_loss))
plt.title('Quad energy')
plt.show()
plt.figure(figsize=(10, 8))
plt.plot(np.array(history_smooth_loss))
plt.title('Smooth energy')
plt.show()
plt.figure(figsize=(10, 8))
plt.semilogy(np.array(history_loss))
plt.title('Data energy')
plt.show()
plt.figure(figsize=(10, 8))
plt.semilogy(np.array(history_p_deviation), c='b', label='from origin')
plt.semilogy(np.array(history_p_deviation_target), c='r', label='from target')
plt.legend()
plt.title('Deviation')
plt.show()
plt.figure(figsize=(10, 8))
plt.semilogy(np.array(history_p_deviation_mean), c='b', label='from origin')
plt.semilogy(np.array(history_p_deviation_target_mean), c='r', label='from target')
plt.legend()
plt.title('Mean deviation')
plt.show()
def make_M_from_tqs(t, q, s):
q = np.quaternion(q[0], q[1], q[2], q[3])
T = np.eye(4)
T[0:3, 3] = t
R = np.eye(4)
R[0:3, 0:3] = quaternion.as_rotation_matrix(q)
S = np.eye(4)
S[0:3, 0:3] = np.diag(s)
M = T.dot(R).dot(S)
return M
def two_tetrahedrons():
vertices_1 = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]])
vertices_2 = np.array([[2, 0, 0], [3, 0, 0], [2, 1, 0], [2, 0, 2]])
faces_1 = np.array([[0, 1, 2], [0, 2, 3], [0, 1, 3], [1, 2, 3],
[0, 2, 1], [0, 3, 2], [0, 3, 1], [1, 3, 2]])
faces_2 = np.array([[0, 1, 2], [0, 2, 3], [0, 1, 3], [1, 2, 3],
[0, 2, 1], [0, 3, 2], [0, 3, 1], [1, 3, 2]])
mesh_1 = Trimesh(vertices_1, faces_1)
mesh_2 = Trimesh(vertices_2, faces_2)
return mesh_1, mesh_2
def sphere(subdivisions=3, radius=1.0):
mesh = trimesh.primitives.Sphere(subdivisions=subdivisions, radius=radius)
return mesh
def plane(width=2, length=2, num_points=2500):
x = np.linspace(0, length, num=int(np.sqrt(num_points)))
y = np.linspace(0, width, num=int(np.sqrt(num_points)))
x, y = np.meshgrid(x, y)
z = np.zeros_like(x)
tri = mtri.Triangulation(x.flatten(), y.flatten())
faces = tri.triangles
faces_dual = faces[: ,[0, 2, 1]]
faces = np.vstack([faces, faces_dual])
vertices = np.array([x.flatten(), y.flatten(), z.flatten()]).T
plane = Trimesh(vertices=vertices, faces=faces)
return plane
def saddle(num_points=2500):
def f(x, y):
return x ** 2 - y ** 2
x = np.linspace(-1, 1, num=int(np.sqrt(num_points)))
y = np.linspace(-1, 1, num=int(np.sqrt(num_points)))
x, y = np.meshgrid(x, y)
z = f(x, y)
tri = mtri.Triangulation(x.flatten(), y.flatten())
faces = tri.triangles
faces_dual = faces[: ,[0, 2, 1]]
faces = np.vstack([faces, faces_dual])
vertices = np.array([x.flatten(), y.flatten(), z.flatten()]).T
saddle = Trimesh(vertices=vertices, faces=faces)
return saddle
def monkey_saddle(num_points=2500):
def f(x, y):
return x ** 3 - 3 * x * y ** 2
x = np.linspace(-1, 1, num=int(np.sqrt(num_points)))
y = np.linspace(-1, 1, num=int(np.sqrt(num_points)))
x, y = np.meshgrid(x, y)
z = f(x, y)
tri = mtri.Triangulation(x.flatten(), y.flatten())
faces = tri.triangles
faces_dual = faces[: ,[0, 2, 1]]
faces = np.vstack([faces, faces_dual])
vertices = np.array([x.flatten(), y.flatten(), z.flatten()]).T
saddle = Trimesh(vertices=vertices, faces=faces)
return saddle
def box(size=(1, 1, 1), max_edge=0.1):
box = trimesh.creation.box(extents=size)
vertices, faces = subdivide_to_size(box.vertices, box.faces, max_edge)
mesh = Trimesh(vertices, faces)
return mesh
def mesh_pcloud(points, size=0.1, color=None):
boxes = []
for point in points:
box = trimesh.creation.box(extents=(size, size, size))
box.apply_transform(translate([point - np.array([size/2, size/2, size/2])]))
if color is not None:
for facet in box.facets:
box.visual.face_colors[facet] = color
boxes += [box]
boxes = trimesh.util.concatenate(boxes)
return boxes
def set_new_mesh_vertices(mesh, vertices):
mesh_new = Trimesh(vertices=vertices.copy(), faces=mesh.faces, process=False)
return mesh_new
def affine_transform(mesh, transform):
mesh_new = mesh.copy()
mesh_new.apply_transform(transform)
return mesh_new
def rot_x(angle=0):
angle = angle * np.pi / 180
return np.array([[1, 0, 0, 0],
[0, np.cos(angle), -np.sin(angle), 0],
[0, np.sin(angle), np.cos(angle), 0],
[0, 0, 0, 1]])
def rot_y(angle=0):
angle = angle * np.pi / 180
return np.array([[np.cos(angle), 0, -np.sin(angle), 0],
[0, 1, 0, 0],
[np.sin(angle), 0, np.cos(angle), 0],
[0, 0, 0, 1]])
def rot_z(angle=0):
angle = angle * np.pi / 180
return np.array([[np.cos(angle), -np.sin(angle), 0, 0],
[np.sin(angle), np.cos(angle), 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])
def translate(vector=(0, 0, 0)):
transform = np.eye(4, dtype=float)
transform[:3, 3] = np.array(vector)
return transform
def scale(scale=(1, 1, 1)):
transform = np.eye(4, dtype=float)
transform[0, 0] = | np.array([scale[0]]) | numpy.array |
# Copyright 2021 <NAME>
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# 3. Neither the name of the copyright holder nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
"""
"""
import unittest
import numpy as np
import sempler
import sempler.generators
import utlvce.utils as utils
# ---------------------------------------------------------------------
NUM_GRAPHS = 500
class PDAG_to_CPDAG_Tests(unittest.TestCase):
# Tests to ensure that the conversion from PDAG to CPDAG
# works
def test_pdag_to_dag_1(self):
# Should work
P = np.array([[0, 0, 1, 0],
[0, 0, 1, 1],
[1, 0, 0, 0],
[0, 0, 0, 0]])
A = utils.pdag_to_dag(P, debug=False)
# print(A)
true_A = P.copy()
true_A[0, 2] = 0
self.assertTrue((A == true_A).all())
def test_pdag_to_dag_2(self):
# Same as above but different index order, should work
P = np.array([[0, 0, 1, 0],
[1, 0, 0, 1],
[1, 0, 0, 0],
[0, 0, 0, 0]])
A = utils.pdag_to_dag(P, debug=False)
# print(A)
true_A = P.copy()
true_A[2, 0] = 0
self.assertTrue((A == true_A).all())
def test_pdag_to_dag_3(self):
# Should work
P = np.array([[0, 0, 1, 0],
[0, 0, 0, 1],
[1, 1, 0, 0],
[0, 0, 0, 0]])
A = utils.pdag_to_dag(P, debug=False)
# print(A)
true_A1, true_A2 = P.copy(), P.copy()
true_A1[0, 2], true_A2[2, 0] = 0, 0
self.assertTrue(utils.member([true_A1, true_A2], A) is not None)
def test_pdag_to_dag_4(self):
# This PDAG does not admit a consistent extension, i.e. it
# either creates a non-existing v-structure or it induces a
# cycle
P = np.array([[0, 0, 1, 1],
[0, 0, 1, 0],
[1, 0, 0, 0],
[0, 0, 1, 0]])
try:
utils.pdag_to_dag(P, debug=False)
self.fail("Exception should have been thrown")
except ValueError as e:
print("OK:", e)
def test_pdag_to_dag_5(self):
# Fully directed PDAG should return itself
A = np.array([[0, 1, 1, 0],
[0, 0, 1, 0],
[0, 0, 0, 0],
[0, 0, 1, 0]])
extension = utils.pdag_to_dag(A, debug=False)
self.assertTrue(utils.is_consistent_extension(extension, A))
self.assertTrue((extension == A).all())
def test_pdag_to_dag_6(self):
# Check that the resulting extensions are indeed a consistent
# extensions
G = NUM_GRAPHS
p = 20
for i in range(G):
A = sempler.generators.dag_avg_deg(p, 3, 1, 1)
cpdag = utils.dag_to_cpdag(A)
self.assertTrue(utils.is_consistent_extension(A, cpdag))
extension = utils.pdag_to_dag(cpdag, debug=False)
is_consistent_extension = utils.is_consistent_extension(
extension, cpdag)
if not is_consistent_extension:
print("DAG\n", A)
print("CPDAG\n", cpdag)
print("Extension\n", extension)
utils.is_consistent_extension(extension, cpdag, debug=True)
# Rerun with outputs
assert (extension == utils.pdag_to_dag(
cpdag, debug=True)).all()
self.assertTrue(is_consistent_extension)
print("\nChecked PDAG to DAG conversion for %d PDAGs" % (i + 1))
def test_order_edges_preconditions(self):
A = np.array([[0, 0, 1, 1, 1], [0, 0, 1, 1, 1], [
0, 0, 0, 1, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0]])
# Check that exception is thrown with pdag
pdag = A.copy()
pdag[4, 2] = 1
try:
utils.order_edges(pdag)
self.fail()
except ValueError as e:
print("OK:", e)
# Check that exception is thrown with cyclic graph
cyclic = pdag.copy()
cyclic[2, 4] = 0
try:
utils.order_edges(cyclic)
self.fail()
except ValueError as e:
print("OK:", e)
def test_order_edges_1(self):
A = np.array([[0, 0, 1, 1, 1], [0, 0, 1, 1, 1], [
0, 0, 0, 1, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0]])
ordered = utils.order_edges(A)
# print(ordered)
# Ground truth derived by hand for the order [1,0,2,3,4]
truth = np.array([[0, 0, 9, 6, 2],
[0, 0, 8, 5, 1],
[0, 0, 0, 7, 3],
[0, 0, 0, 0, 4],
[0, 0, 0, 0, 0]])
self.assertTrue((ordered >= 0).all())
self.assertTrue((ordered == truth).all())
def test_order_edges_2(self):
G = NUM_GRAPHS
p = 20
for i in range(G):
A = sempler.generators.dag_avg_deg(p, 3, 1, 1)
ordered = utils.order_edges(A)
no_edges = (A != 0).sum()
self.assertEqual(sorted(ordered[ordered != 0]), list(
range(1, no_edges + 1)))
print("\nChecked valid ordering for %d DAGs" % (i + 1))
def test_label_edges_preconditions(self):
A = np.array([[0, 0, 1, 1, 1], [0, 0, 1, 1, 1], [
0, 0, 0, 1, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0]])
# Check that exception is thrown with pdag
pdag = A.copy()
pdag[4, 2] = 1
try:
utils.order_edges(pdag)
self.fail()
except ValueError as e:
print("OK:", e)
# Check that exception is thrown with cyclic graph
cyclic = pdag.copy()
cyclic[2, 4] = 0
try:
utils.order_edges(cyclic)
self.fail()
except ValueError as e:
print("OK:", e)
# Check that if ordering is invalid an exception is thrown
try:
utils.label_edges(A)
self.fail()
except ValueError as e:
print("OK:", e)
# Same same, but different :)
ordered = utils.order_edges(A)
ordered[0, 4] = 1
try:
utils.label_edges(ordered)
self.fail()
except ValueError as e:
print("OK:", e)
def test_label_edges_1(self):
# For a hand-picked example
A = np.array([[0, 0, 1, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 1, 1],
[0, 0, 0, 0, 1],
[0, 0, 0, 0, 0]])
ordered = utils.order_edges(A)
truth = np.array([[0, 0, 1, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 1, 1],
[0, 0, 0, 0, -1],
[0, 0, 0, 0, 0]])
labelled = utils.label_edges(ordered)
self.assertTrue((labelled == truth).all())
def test_label_edges_2(self):
# With randomly generated DAGs
# np.random.seed(42)
G = NUM_GRAPHS
p = 20
for i in range(G):
A = sempler.generators.dag_avg_deg(p, 3, 1, 1)
# Construct expected output
cpdag = utils.dag_to_cpdag(A)
undirected = np.logical_and(cpdag, cpdag.T)
truth = A.copy()
truth[np.logical_and(truth, undirected)] = -1
# Run and assert
ordered = utils.order_edges(A)
labelled = utils.label_edges(ordered)
self.assertTrue((labelled == truth).all())
print("\nChecked edge labelling for %d DAGs" % (i + 1))
def test_dag_to_cpdag(self):
# Test by checking that applying the whole pipeline to a CPDAG
# returns the same CPDAG
G = NUM_GRAPHS
p = 25
for i in range(G):
A = sempler.generators.dag_avg_deg(p, 4, 1, 1)
truth = utils.dag_to_cpdag(A)
# Run and assert
cpdag = utils.dag_to_cpdag(A)
self.assertTrue((truth == cpdag).all())
print("\nChecked DAG to CPDAG conversion for %d DAGs" % (i + 1))
def test_cpdag_to_cpdag(self):
# Test by checking that applying the whole pipeline to a CPDAG
# returns the same CPDAG
G = NUM_GRAPHS
p = 30
for i in range(G):
A = sempler.generators.dag_avg_deg(p, 3, 1, 1)
cpdag = utils.dag_to_cpdag(A)
# Run and assert
output = utils.pdag_to_cpdag(cpdag)
self.assertTrue((output == cpdag).all())
print("\nChecked CPDAG to CPDAG conversion for %d CPDAGs" % (i + 1))
def test_pdag_to_cpdag(self):
# Now construct PDAGs whose extensions belong to the true MEC,
# and test that the true CPDAG is recovered
G = NUM_GRAPHS
p = 32
for g in range(G):
A = sempler.generators.dag_avg_deg(p, 3, 1, 1)
# Construct PDAG by undirecting random edges which do not
# belong to a v-structure.
# NOTE: I'm proceeding in this awkward way to avoid
# using functions from the pipeline I'm testing,
# i.e. utils.order_edges and utils.label_edges
pdag = A.copy()
mask_vstructs = | np.zeros_like(A) | numpy.zeros_like |
"""
## pyart radar object
pyart.core.radar
================
A general central radial scanning (or dwelling) instrument class.
.. autosummary::
:toctree: generated/
_rays_per_sweep_data_factory
_gate_data_factory
_gate_lon_lat_data_factory
_gate_altitude_data_factory
.. autosummary::
:toctree: generated/
:template: dev_template.rst
Radar
"""
# the code for Radar Object in this file were adapted from pyart by <NAME>. & <NAME>.
# https://github.com/ARM-DOE/pyart
from __future__ import print_function
import numpy as np
import sys
from ..configure.pyart_config import get_metadata
from ..configure.pyart_lazydict import LazyLoadDict
from .transforms import antenna_vectors_to_cartesian, cartesian_to_geographic
class Radar(object):
"""
A class for storing antenna coordinate radar data.
The structure of the Radar class is based on the CF/Radial Data file
format. Global attributes and variables (section 4.1 and 4.3) are
represented as a dictionary in the metadata attribute. Other required and
optional variables are represented as dictionaries in a attribute with the
same name as the variable in the CF/Radial standard. When a optional
attribute not present the attribute has a value of None. The data for a
given variable is stored in the dictionary under the 'data' key. Moment
field data is stored as a dictionary of dictionaries in the fields
attribute. Sub-convention variables are stored as a dictionary of
dictionaries under the meta_group attribute.
Refer to the attribute section for information on the parameters.
Attributes
----------
time : dict
Time at the center of each ray.
range : dict
Range to the center of each gate (bin).
fields : dict of dicts
Moment fields.
metadata : dict
Metadata describing the instrument and data.
scan_type : str
Type of scan, one of 'ppi', 'rhi', 'sector' or 'other'. If the scan
volume contains multiple sweep modes this should be 'other'.
latitude : dict
Latitude of the instrument.
longitude : dict
Longitude of the instrument.
altitude : dict
Altitude of the instrument, above sea level.
altitude_agl : dict or None
Altitude of the instrument above ground level. If not provided this
attribute is set to None, indicating this parameter not available.
sweep_number : dict
The number of the sweep in the volume scan, 0-based.
sweep_mode : dict
Sweep mode for each mode in the volume scan.
fixed_angle : dict
Target angle for thr sweep. Azimuth angle in RHI modes, elevation
angle in all other modes.
sweep_start_ray_index : dict
Index of the first ray in each sweep relative to the start of the
volume, 0-based.
sweep_end_ray_index : dict
Index of the last ray in each sweep relative to the start of the
volume, 0-based.
rays_per_sweep : LazyLoadDict
Number of rays in each sweep. The data key of this attribute is
create upon first access from the data in the sweep_start_ray_index and
sweep_end_ray_index attributes. If the sweep locations needs to be
modified, do this prior to accessing this attribute or use
:py:func:`init_rays_per_sweep` to reset the attribute.
target_scan_rate : dict or None
Intended scan rate for each sweep. If not provided this attribute is
set to None, indicating this parameter is not available.
rays_are_indexed : dict or None
Indication of whether ray angles are indexed to a regular grid in
each sweep. If not provided this attribute is set to None, indicating
ray angle spacing is not determined.
ray_angle_res : dict or None
If rays_are_indexed is not None, this provides the angular resolution
of the grid. If not provided or available this attribute is set to
None.
azimuth : dict
Azimuth of antenna, relative to true North. Azimuth angles are
recommended to be expressed in the range of [0, 360], but other
representations are not forbidden.
elevation : dict
Elevation of antenna, relative to the horizontal plane. Elevation
angles are recommended to be expressed in the range of [-180, 180],
but other representations are not forbidden.
gate_x, gate_y, gate_z : LazyLoadDict
Location of each gate in a Cartesian coordinate system assuming a
standard atmosphere with a 4/3 Earth's radius model. The data keys of
these attributes are create upon first access from the data in the
range, azimuth and elevation attributes. If these attributes are
changed use :py:func:`init_gate_x_y_z` to reset.
gate_longitude, gate_latitude : LazyLoadDict
Geographic location of each gate. The projection parameter(s) defined
in the `projection` attribute are used to perform an inverse map
projection from the Cartesian gate locations relative to the radar
location to longitudes and latitudes. If these attributes are changed
use :py:func:`init_gate_longitude_latitude` to reset the attributes.
projection : dic or str
Projection parameters defining the map projection used to transform
from Cartesian to geographic coordinates. The default dictionary sets
the 'proj' key to 'pyart_aeqd' indicating that the native Py-ART
azimuthal equidistant projection is used. This can be modified to
specify a valid pyproj.Proj projparams dictionary or string.
The special key '_include_lon_0_lat_0' is removed when interpreting
this dictionary. If this key is present and set to True, which is
required when proj='pyart_aeqd', then the radar longitude and
latitude will be added to the dictionary as 'lon_0' and 'lat_0'.
gate_altitude : LazyLoadDict
The altitude of each radar gate as calculated from the altitude of the
radar and the Cartesian z location of each gate. If this attribute
is changed use :py:func:`init_gate_altitude` to reset the attribute.
scan_rate : dict or None
Actual antenna scan rate. If not provided this attribute is set to
None, indicating this parameter is not available.
antenna_transition : dict or None
Flag indicating if the antenna is in transition, 1 = yes, 0 = no.
If not provided this attribute is set to None, indicating this
parameter is not available.
rotation : dict or None
The rotation angle of the antenna. The angle about the aircraft
longitudinal axis for a vertically scanning radar.
tilt : dict or None
The tilt angle with respect to the plane orthogonal (Z-axis) to
aircraft longitudinal axis.
roll : dict or None
The roll angle of platform, for aircraft right wing down is positive.
drift : dict or None
Drift angle of antenna, the angle between heading and track.
heading : dict or None
Heading (compass) angle, clockwise from north.
pitch : dict or None
Pitch angle of antenna, for aircraft nose up is positive.
georefs_applied : dict or None
Indicates whether the variables have had georeference calculation
applied. Leading to Earth-centric azimuth and elevation angles.
instrument_parameters : dict of dicts or None
Instrument parameters, if not provided this attribute is set to None,
indicating these parameters are not avaiable. This dictionary also
includes variables in the radar_parameters CF/Radial subconvention.
radar_calibration : dict of dicts or None
Instrument calibration parameters. If not provided this attribute is
set to None, indicating these parameters are not available
ngates : int
Number of gates (bins) in a ray.
nrays : int
Number of rays in the volume.
nsweeps : int
Number of sweep in the volume.
"""
def __init__(self, time, _range, fields, metadata, scan_type,
latitude, longitude, altitude,
sweep_number, sweep_mode, fixed_angle, sweep_start_ray_index,
sweep_end_ray_index,
azimuth, elevation,
altitude_agl=None,
target_scan_rate=None, rays_are_indexed=None,
ray_angle_res=None,
scan_rate=None, antenna_transition=None,
instrument_parameters=None,
radar_calibration=None,
rotation=None, tilt=None, roll=None, drift=None, heading=None,
pitch=None, georefs_applied=None,
):
if 'calendar' not in time:
time['calendar'] = 'gregorian'
self.time = time
self.range = _range
self.fields = fields
self.metadata = metadata
self.scan_type = scan_type
self.latitude = latitude
self.longitude = longitude
self.altitude = altitude
self.altitude_agl = altitude_agl # optional
self.sweep_number = sweep_number
self.sweep_mode = sweep_mode
self.fixed_angle = fixed_angle
self.sweep_start_ray_index = sweep_start_ray_index
self.sweep_end_ray_index = sweep_end_ray_index
self.target_scan_rate = target_scan_rate # optional
self.rays_are_indexed = rays_are_indexed # optional
self.ray_angle_res = ray_angle_res # optional
self.azimuth = azimuth
self.elevation = elevation
self.scan_rate = scan_rate # optional
self.antenna_transition = antenna_transition # optional
self.rotation = rotation # optional
self.tilt = tilt # optional
self.roll = roll # optional
self.drift = drift # optional
self.heading = heading # optional
self.pitch = pitch # optional
self.georefs_applied = georefs_applied # optional
self.instrument_parameters = instrument_parameters # optional
self.radar_calibration = radar_calibration # optional
self.ngates = len(_range['data'])
self.nrays = len(time['data'])
self.nsweeps = len(sweep_number['data'])
self.projection = {'proj': 'pyart_aeqd', '_include_lon_0_lat_0': True}
# initalize attributes with lazy load dictionaries
self.init_rays_per_sweep()
self.init_gate_x_y_z()
self.init_gate_longitude_latitude()
self.init_gate_altitude()
def __getstate__(self):
""" Return object's state which can be pickled. """
state = self.__dict__.copy() # copy the objects state
# Remove unpicklable entries (those which are lazily loaded
del state['rays_per_sweep']
del state['gate_x']
del state['gate_y']
del state['gate_z']
del state['gate_longitude']
del state['gate_latitude']
del state['gate_altitude']
return state
def __setstate__(self, state):
""" Restore unpicklable entries from pickled object. """
self.__dict__.update(state)
self.init_rays_per_sweep()
self.init_gate_x_y_z()
self.init_gate_longitude_latitude()
self.init_gate_altitude()
# Attribute init/reset method
def init_rays_per_sweep(self):
""" Initialize or reset the rays_per_sweep attribute. """
lazydic = LazyLoadDict(get_metadata('rays_per_sweep'))
lazydic.set_lazy('data', _rays_per_sweep_data_factory(self))
self.rays_per_sweep = lazydic
def init_gate_x_y_z(self):
""" Initialize or reset the gate_{x, y, z} attributes. """
gate_x = LazyLoadDict(get_metadata('gate_x'))
gate_x.set_lazy('data', _gate_data_factory(self, 0))
self.gate_x = gate_x
gate_y = LazyLoadDict(get_metadata('gate_y'))
gate_y.set_lazy('data', _gate_data_factory(self, 1))
self.gate_y = gate_y
gate_z = LazyLoadDict(get_metadata('gate_z'))
gate_z.set_lazy('data', _gate_data_factory(self, 2))
self.gate_z = gate_z
def init_gate_longitude_latitude(self):
"""
Initialize or reset the gate_longitude and gate_latitude attributes.
"""
gate_longitude = LazyLoadDict(get_metadata('gate_longitude'))
gate_longitude.set_lazy('data', _gate_lon_lat_data_factory(self, 0))
self.gate_longitude = gate_longitude
gate_latitude = LazyLoadDict(get_metadata('gate_latitude'))
gate_latitude.set_lazy('data', _gate_lon_lat_data_factory(self, 1))
self.gate_latitude = gate_latitude
def init_gate_altitude(self):
""" Initialize the gate_altitude attribute. """
gate_altitude = LazyLoadDict(get_metadata('gate_altitude'))
gate_altitude.set_lazy('data', _gate_altitude_data_factory(self))
self.gate_altitude = gate_altitude
# private functions for checking limits, etc.
def _check_sweep_in_range(self, sweep):
""" Check that a sweep number is in range. """
if sweep < 0 or sweep >= self.nsweeps:
raise IndexError('Sweep out of range: ', sweep)
return
# public check functions
def check_field_exists(self, field_name):
"""
Check that a field exists in the fields dictionary.
If the field does not exist raise a KeyError.
Parameters
----------
field_name : str
Name of field to check.
"""
if field_name not in self.fields:
raise KeyError('Field not available: ' + field_name)
return
# Iterators
def iter_start(self):
""" Return an iterator over the sweep start indices. """
return (s for s in self.sweep_start_ray_index['data'])
def iter_end(self):
""" Return an iterator over the sweep end indices. """
return (s for s in self.sweep_end_ray_index['data'])
def iter_start_end(self):
""" Return an iterator over the sweep start and end indices. """
return ((s, e) for s, e in zip(self.iter_start(), self.iter_end()))
def iter_slice(self):
""" Return an iterator which returns sweep slice objects. """
return (slice(s, e+1) for s, e in self.iter_start_end())
def iter_field(self, field_name):
""" Return an iterator which returns sweep field data. """
self.check_field_exists(field_name)
return (self.fields[field_name]['data'][s] for s in self.iter_slice())
def iter_azimuth(self):
""" Return an iterator which returns sweep azimuth data. """
return (self.azimuth['data'][s] for s in self.iter_slice())
def iter_elevation(self):
""" Return an iterator which returns sweep elevation data. """
return (self.elevation['data'][s] for s in self.iter_slice())
# get methods
def get_start(self, sweep):
""" Return the starting ray index for a given sweep. """
self._check_sweep_in_range(sweep)
return self.sweep_start_ray_index['data'][sweep]
def get_end(self, sweep):
""" Return the ending ray for a given sweep. """
self._check_sweep_in_range(sweep)
return self.sweep_end_ray_index['data'][sweep]
def get_start_end(self, sweep):
""" Return the starting and ending ray for a given sweep. """
return self.get_start(sweep), self.get_end(sweep)
def get_slice(self, sweep):
""" Return a slice for selecting rays for a given sweep. """
start, end = self.get_start_end(sweep)
return slice(start, end+1)
def get_field(self, sweep, field_name, copy=False):
"""
Return the field data for a given sweep.
When used with :py:func:`get_gate_x_y_z` this method can be used to
obtain the data needed for plotting a radar field with the correct
spatial context.
Parameters
----------
sweep : int
Sweep number to retrieve data for, 0 based.
field_name : str
Name of the field from which data should be retrieved.
copy : bool, optional
True to return a copy of the data. False, the default, returns
a view of the data (when possible), changing this data will
change the data in the underlying Radar object.
Returns
-------
data : array
Array containing data for the requested sweep and field.
"""
self.check_field_exists(field_name)
s = self.get_slice(sweep)
data = self.fields[field_name]['data'][s]
if copy:
return data.copy()
else:
return data
def get_azimuth(self, sweep, copy=False):
"""
Return an array of azimuth angles for a given sweep.
Parameters
----------
sweep : int
Sweep number to retrieve data for, 0 based.
copy : bool, optional
True to return a copy of the azimuths. False, the default, returns
a view of the azimuths (when possible), changing this data will
change the data in the underlying Radar object.
Returns
-------
azimuths : array
Array containing the azimuth angles for a given sweep.
"""
s = self.get_slice(sweep)
azimuths = self.azimuth['data'][s]
if copy:
return azimuths.copy()
else:
return azimuths
def get_elevation(self, sweep, copy=False):
"""
Return an array of elevation angles for a given sweep.
Parameters
----------
sweep : int
Sweep number to retrieve data for, 0 based.
copy : bool, optional
True to return a copy of the elevations. False, the default,
returns a view of the elevations (when possible), changing this
data will change the data in the underlying Radar object.
Returns
-------
azimuths : array
Array containing the elevation angles for a given sweep.
"""
s = self.get_slice(sweep)
elevation = self.elevation['data'][s]
if copy:
return elevation.copy()
else:
return elevation
def get_gate_x_y_z(self, sweep, edges=False, filter_transitions=False):
"""
Return the x, y and z gate locations in meters for a given sweep.
With the default parameter this method returns the same data as
contained in the gate_x, gate_y and gate_z attributes but this method
performs the gate location calculations only for the specified sweep
and therefore is more efficient than accessing this data through these
attribute.
When used with :py:func:`get_field` this method can be used to obtain
the data needed for plotting a radar field with the correct spatial
context.
Parameters
----------
sweep : int
Sweep number to retrieve gate locations from, 0 based.
edges : bool, optional
True to return the locations of the gate edges calculated by
interpolating between the range, azimuths and elevations.
False (the default) will return the locations of the gate centers
with no interpolation.
filter_transitions : bool, optional
True to remove rays where the antenna was in transition between
sweeps. False will include these rays. No rays will be removed
if the antenna_transition attribute is not available (set to None).
Returns
-------
x, y, z : 2D array
Array containing the x, y and z, distances from the radar in
meters for the center (or edges) for all gates in the sweep.
"""
azimuths = self.get_azimuth(sweep)
elevations = self.get_elevation(sweep)
if filter_transitions and self.antenna_transition is not None:
sweep_slice = self.get_slice(sweep)
valid = self.antenna_transition['data'][sweep_slice] == 0
azimuths = azimuths[valid]
elevations = elevations[valid]
return antenna_vectors_to_cartesian(
self.range['data'], azimuths, elevations, edges=edges)
def get_gate_lat_lon_alt(self, sweep, reset_gate_coords=False,
filter_transitions=False):
"""
Return the longitude, latitude and altitude gate locations.
Longitude and latitude are in degrees and altitude in meters.
With the default parameter this method returns the same data as
contained in the gate_latitude, gate_longitude and gate_altitude
attributes but this method performs the gate location calculations
only for the specified sweep and therefore is more efficient than
accessing this data through these attribute. If coordinates have
at all, please use the reset_gate_coords parameter.
Parameters
----------
sweep : int
Sweep number to retrieve gate locations from, 0 based.
reset_gate_coords : bool, optional
Optional to reset the gate latitude, gate longitude and gate
altitude attributes before using them in this function. This
is useful when the geographic coordinates have changed and gate
latitude, gate longitude and gate altitude need to be reset.
filter_transitions : bool, optional
True to remove rays where the antenna was in transition between
sweeps. False will include these rays. No rays will be removed
if the antenna_transition attribute is not available (set to None).
Returns
-------
lat, lon, alt : 2D array
Array containing the latitude, longitude and altitude,
for all gates in the sweep.
"""
s = self.get_slice(sweep)
if reset_gate_coords:
gate_latitude = LazyLoadDict(get_metadata('gate_latitude'))
gate_latitude.set_lazy('data', _gate_lon_lat_data_factory(self, 1))
self.gate_latitude = gate_latitude
gate_longitude = LazyLoadDict(get_metadata('gate_longitude'))
gate_longitude.set_lazy('data', _gate_lon_lat_data_factory(self, 0))
self.gate_longitude = gate_longitude
gate_altitude = LazyLoadDict(get_metadata('gate_altitude'))
gate_altitude.set_lazy('data', _gate_altitude_data_factory(self))
self.gate_altitude = gate_altitude
lat = self.gate_latitude['data'][s]
lon = self.gate_longitude['data'][s]
alt = self.gate_altitude['data'][s]
if filter_transitions and self.antenna_transition is not None:
valid = self.antenna_transition['data'][s] == 0
lat = lat[valid]
lon = lon[valid]
alt = alt[valid]
return lat, lon, alt
def get_nyquist_vel(self, sweep, check_uniform=True):
"""
Return the Nyquist velocity in meters per second for a given sweep.
Raises a LookupError if the Nyquist velocity is not available, an
Exception is raised if the velocities are not uniform in the sweep
unless check_uniform is set to False.
Parameters
----------
sweep : int
Sweep number to retrieve data for, 0 based.
check_uniform : bool
True to check to perform a check on the Nyquist velocities that
they are uniform in the sweep, False will skip this check and
return the velocity of the first ray in the sweep.
Returns
-------
nyquist_velocity : float
Array containing the Nyquist velocity in m/s for a given sweep.
"""
s = self.get_slice(sweep)
try:
nyq_vel = self.instrument_parameters['nyquist_velocity']['data'][s]
except:
raise LookupError('Nyquist velocity unavailable')
if check_uniform:
if np.any(nyq_vel != nyq_vel[0]):
raise Exception('Nyquist velocities are not uniform in sweep')
return float(nyq_vel[0])
# Methods
def info(self, level='standard', out=sys.stdout):
"""
Print information on radar.
Parameters
----------
level : {'compact', 'standard', 'full', 'c', 's', 'f'}, optional
Level of information on radar object to print, compact is
minimal information, standard more and full everything.
out : file-like, optional
Stream to direct output to, default is to print information
to standard out (the screen).
"""
if level == 'c':
level = 'compact'
elif level == 's':
level = 'standard'
elif level == 'f':
level = 'full'
if level not in ['standard', 'compact', 'full']:
raise ValueError('invalid level parameter')
self._dic_info('altitude', level, out)
self._dic_info('altitude_agl', level, out)
self._dic_info('antenna_transition', level, out)
self._dic_info('azimuth', level, out)
self._dic_info('elevation', level, out)
print('fields:', file=out)
for field_name, field_dic in self.fields.items():
self._dic_info(field_name, level, out, field_dic, 1)
self._dic_info('fixed_angle', level, out)
if self.instrument_parameters is None:
print('instrument_parameters: None', file=out)
else:
print('instrument_parameters:', file=out)
for name, dic in self.instrument_parameters.items():
self._dic_info(name, level, out, dic, 1)
self._dic_info('latitude', level, out)
self._dic_info('longitude', level, out)
print('nsweeps:', self.nsweeps, file=out)
print('ngates:', self.ngates, file=out)
print('nrays:', self.nrays, file=out)
if self.radar_calibration is None:
print('radar_calibration: None', file=out)
else:
print('radar_calibration:', file=out)
for name, dic in self.radar_calibration.items():
self._dic_info(name, level, out, dic, 1)
self._dic_info('range', level, out)
self._dic_info('scan_rate', level, out)
print('scan_type:', self.scan_type, file=out)
self._dic_info('sweep_end_ray_index', level, out)
self._dic_info('sweep_mode', level, out)
self._dic_info('sweep_number', level, out)
self._dic_info('sweep_start_ray_index', level, out)
self._dic_info('target_scan_rate', level, out)
self._dic_info('time', level, out)
# Airborne radar parameters
if self.rotation is not None:
self._dic_info('rotation', level, out)
if self.tilt is not None:
self._dic_info('tilt', level, out)
if self.roll is not None:
self._dic_info('roll', level, out)
if self.drift is not None:
self._dic_info('drift', level, out)
if self.heading is not None:
self._dic_info('heading', level, out)
if self.pitch is not None:
self._dic_info('pitch', level, out)
if self.georefs_applied is not None:
self._dic_info('georefs_applied', level, out)
# always print out all metadata last
self._dic_info('metadata', 'full', out)
def _dic_info(self, attr, level, out, dic=None, ident_level=0):
""" Print information on a dictionary attribute. """
if dic is None:
dic = getattr(self, attr)
ilvl0 = '\t' * ident_level
ilvl1 = '\t' * (ident_level + 1)
if dic is None:
print(str(attr) + ': None', file=out)
return
# make a string summary of the data key if it exists.
if 'data' not in dic:
d_str = 'Missing'
elif not isinstance(dic['data'], np.ndarray):
d_str = '<not a ndarray>'
else:
data = dic['data']
t = (data.dtype, data.shape)
d_str = '<ndarray of type: %s and shape: %s>' % t
# compact, only data summary
if level == 'compact':
print(ilvl0 + str(attr) + ':', d_str, file=out)
# standard, all keys, only summary for data
elif level == 'standard':
print(ilvl0 + str(attr) + ':', file=out)
print(ilvl1 + 'data:', d_str, file=out)
for key, val in dic.items():
if key == 'data':
continue
print(ilvl1 + key + ':', val, file=out)
# full, all keys, full data
elif level == 'full':
print(str(attr) + ':', file=out)
if 'data' in dic:
print(ilvl1 + 'data:', dic['data'], file=out)
for key, val in dic.items():
if key == 'data':
continue
print(ilvl1 + key + ':', val, file=out)
return
def add_field(self, field_name, dic, replace_existing=False):
"""
Add a field to the object.
Parameters
----------
field_name : str
Name of the field to add to the dictionary of fields.
dic : dict
Dictionary contain field data and metadata.
replace_existing : bool, optional
True to replace the existing field with key field_name if it
exists, loosing any existing data. False will raise a ValueError
when the field already exists.
"""
# check that the field dictionary to add is valid
if field_name in self.fields and replace_existing is False:
err = 'A field with name: %s already exists' % (field_name)
raise ValueError(err)
if 'data' not in dic:
raise KeyError("dic must contain a 'data' key")
if dic['data'].shape != (self.nrays, self.ngates):
t = (self.nrays, self.ngates)
err = "'data' has invalid shape, should be (%i, %i)" % t
raise ValueError(err)
# add the field
self.fields[field_name] = dic
return
def add_field_like(self, existing_field_name, field_name, data,
replace_existing=False):
"""
Add a field to the object with metadata from a existing field.
Note that the data parameter is not copied by this method.
If data refers to a 'data' array from an existing field dictionary, a
copy should be made within or prior to using this method. If this is
not done the 'data' key in both field dictionaries will point to the
same NumPy array and modification of one will change the second. To
copy NumPy arrays use the copy() method. See the Examples section
for how to create a copy of the 'reflectivity' field as a field named
'reflectivity_copy'.
Parameters
----------
existing_field_name : str
Name of an existing field to take metadata from when adding
the new field to the object.
field_name : str
Name of the field to add to the dictionary of fields.
data : array
Field data. A copy of this data is not made, see the note above.
replace_existing : bool, optional
True to replace the existing field with key field_name if it
exists, loosing any existing data. False will raise a ValueError
when the field already exists.
Examples
--------
>>> radar.add_field_like('reflectivity', 'reflectivity_copy',
... radar.fields['reflectivity']['data'].copy())
"""
if existing_field_name not in self.fields:
err = 'field %s does not exist in object' % (existing_field_name)
raise ValueError(err)
dic = {}
for k, v in self.fields[existing_field_name].items():
if k != 'data':
dic[k] = v
dic['data'] = data
return self.add_field(field_name, dic,
replace_existing=replace_existing)
def extract_sweeps(self, sweeps):
"""
Create a new radar contains only the data from select sweeps.
Parameters
----------
sweeps : array_like
Sweeps (0-based) to include in new Radar object.
Returns
-------
radar : Radar
Radar object which contains a copy of data from the selected
sweeps.
"""
# parse and verify parameters
sweeps = np.array(sweeps, dtype='int32')
if np.any(sweeps > (self.nsweeps - 1)):
raise ValueError('invalid sweeps indices in sweeps parameter')
if np.any(sweeps < 0):
raise ValueError('only positive sweeps can be extracted')
def mkdic(dic, select):
""" Make a dictionary, selecting out select from data key """
if dic is None:
return None
d = dic.copy()
if 'data' in d and select is not None:
d['data'] = d['data'][select].copy()
return d
# create array of rays which select the sweeps selected and
# the number of rays per sweep.
ray_count = (self.sweep_end_ray_index['data'] -
self.sweep_start_ray_index['data'] + 1)[sweeps]
ssri = self.sweep_start_ray_index['data'][sweeps]
rays = np.concatenate(
[range(s, s+e) for s, e in zip(ssri, ray_count)]).astype('int32')
# radar location attribute dictionary selector
if len(self.altitude['data']) == 1:
loc_select = None
else:
loc_select = sweeps
# create new dictionaries
time = mkdic(self.time, rays)
_range = mkdic(self.range, None)
fields = {}
for field_name, dic in self.fields.items():
fields[field_name] = mkdic(dic, rays)
metadata = mkdic(self.metadata, None)
scan_type = str(self.scan_type)
latitude = mkdic(self.latitude, loc_select)
longitude = mkdic(self.longitude, loc_select)
altitude = mkdic(self.altitude, loc_select)
altitude_agl = mkdic(self.altitude_agl, loc_select)
sweep_number = mkdic(self.sweep_number, sweeps)
sweep_mode = mkdic(self.sweep_mode, sweeps)
fixed_angle = mkdic(self.fixed_angle, sweeps)
sweep_start_ray_index = mkdic(self.sweep_start_ray_index, None)
sweep_start_ray_index['data'] = np.cumsum(
np.append([0], ray_count[:-1]), dtype='int32')
sweep_end_ray_index = mkdic(self.sweep_end_ray_index, None)
sweep_end_ray_index['data'] = np.cumsum(ray_count, dtype='int32') - 1
target_scan_rate = mkdic(self.target_scan_rate, sweeps)
azimuth = mkdic(self.azimuth, rays)
elevation = mkdic(self.elevation, rays)
scan_rate = mkdic(self.scan_rate, rays)
antenna_transition = mkdic(self.antenna_transition, rays)
# instrument_parameters
# Filter the instrument_parameter dictionary based size of leading
# dimension, this might not always be correct.
if self.instrument_parameters is None:
instrument_parameters = None
else:
instrument_parameters = {}
for key, dic in self.instrument_parameters.items():
if dic['data'].ndim != 0:
dim0_size = dic['data'].shape[0]
else:
dim0_size = -1
if dim0_size == self.nsweeps:
fdic = mkdic(dic, sweeps)
elif dim0_size == self.nrays:
fdic = mkdic(dic, rays)
else: # keep everything
fdic = mkdic(dic, None)
instrument_parameters[key] = fdic
# radar_calibration
# copy all field in radar_calibration as is except for
# r_calib_index which we filter based upon time. This might
# leave some indices in the "r_calib" dimension not referenced in
# the r_calib_index array.
if self.radar_calibration is None:
radar_calibration = None
else:
radar_calibration = {}
for key, dic in self.radar_calibration.items():
if key == 'r_calib_index':
radar_calibration[key] = mkdic(dic, rays)
else:
radar_calibration[key] = mkdic(dic, None)
return Radar(time, _range, fields, metadata, scan_type,
latitude, longitude, altitude,
sweep_number, sweep_mode, fixed_angle,
sweep_start_ray_index, sweep_end_ray_index,
azimuth, elevation,
altitude_agl=altitude_agl,
target_scan_rate=target_scan_rate,
scan_rate=scan_rate,
antenna_transition=antenna_transition,
instrument_parameters=instrument_parameters,
radar_calibration=radar_calibration)
def _rays_per_sweep_data_factory(radar):
""" Return a function which returns the number of rays per sweep. """
def _rays_per_sweep_data():
""" The function which returns the number of rays per sweep. """
return (radar.sweep_end_ray_index['data'] -
radar.sweep_start_ray_index['data'] + 1)
return _rays_per_sweep_data
def _gate_data_factory(radar, coordinate):
""" Return a function which returns the Cartesian locations of gates. """
def _gate_data():
""" The function which returns the Cartesian locations of gates. """
ranges = radar.range['data']
azimuths = radar.azimuth['data']
elevations = radar.elevation['data']
cartesian_coords = antenna_vectors_to_cartesian(
ranges, azimuths, elevations, edges=False)
# load x, y, and z data except for the coordinate in question
if coordinate != 0:
radar.gate_x['data'] = cartesian_coords[0]
if coordinate != 1:
radar.gate_y['data'] = cartesian_coords[1]
if coordinate != 2:
radar.gate_z['data'] = cartesian_coords[2]
return cartesian_coords[coordinate]
return _gate_data
def _gate_lon_lat_data_factory(radar, coordinate):
""" Return a function which returns the geographic locations of gates. """
def _gate_lon_lat_data():
""" The function which returns the geographic locations gates. """
x = radar.gate_x['data']
y = radar.gate_y['data']
projparams = radar.projection.copy()
if projparams.pop('_include_lon_0_lat_0', False):
projparams['lon_0'] = radar.longitude['data'][0]
projparams['lat_0'] = radar.latitude['data'][0]
geographic_coords = cartesian_to_geographic(x, y, projparams)
# set the other geographic coordinate
if coordinate == 0:
radar.gate_latitude['data'] = geographic_coords[1]
else:
radar.gate_longitude['data'] = geographic_coords[0]
return geographic_coords[coordinate]
return _gate_lon_lat_data
def _gate_altitude_data_factory(radar):
""" Return a function which returns the gate altitudes. """
def _gate_altitude_data():
""" The function which returns the gate altitudes. """
try:
return radar.altitude['data'] + radar.gate_z['data']
except ValueError:
return | np.mean(radar.altitude['data']) | numpy.mean |
# %%
from nilearn import surface
from nilearn import datasets
from nilearn import plotting
from nilearn import image
from nilearn import regions
from nilearn.surface import load_surf_mesh
import os
import pylab as plt
import numpy as np
from matplotlib import colors as clr
import matplotlib.patches as mpatches
import matplotlib
matplotlib.__version__
# import mayavi
# np.load('/home/ubuntu/hcp_data/jpg_256/split_videos_256x256/7T_MOVIE4_HO2_v2_256x256/7T_MOVIE4_HO2_v2_256x256_seg_0_72.npy').shape
# %%
def get_faces(faces, parc_idx):
'''Returns a boolean array indicating if a faces from lies on the outer edge of the parcellation defined by the indices in parc_idx
IN:
faces - numpy ndarray of shape (n, 3), containing indices of the mesh faces
parc_idx - indices of the vertices belonging to the region that is to be plotted
'''
faces_in_parc = np.array([np.isin(face, parc_idx) for face in faces])
vertices_on_edge = np.intersect1d(np.unique(faces[faces_in_parc.sum(axis=1)==2]), parc_idx)
faces_outside_edge = np.array([np.isin(face, vertices_on_edge) for face in faces]).sum(axis=1)
faces_outside_edge = np.logical_and(faces_outside_edge > 0, faces_in_parc.sum(axis=1)<3)
return faces_outside_edge
def modify_facecolors(new_color, faces_to_modify, axes):
'''Modifies colors of mesh in axes by replacing all faces in faces_to_modify with new_color'''
if isinstance(new_color, str):
new_color = np.array(clr.to_rgb(color)+(1.,))
poly = axes.collections[0]
# fcolors = poly._facecolor
fcolors = poly._facecolors3d
# _facecolor
fcolors[faces_outside] = np.array(new_color)
poly._facecolors3d = fcolors
return axes
# %%
# path parameters and fsaverage
main_dir = '/home/ubuntu'
result_dir = os.path.join(main_dir, 'results', 'cross_subject')
fsaverage = datasets.fetch_surf_fsaverage(mesh='fsaverage5')
# /home/ubuntu/tk_trial/LSTM/results/cross_subject/groupbeta_0.nii.gz
# group_fname = os.path.join(result_dir, "groupbeta_0.nii.gz")
group_fname = '/home/ubuntu/tk_trial/LSTM/results/cross_subject/groupbeta_0.nii.gz'
group = image.load_img(group_fname)
group0_surf_R = surface.vol_to_surf(group, fsaverage.pial_right)
group0_surf_L = surface.vol_to_surf(group, fsaverage.pial_left)
group_fname = '/home/ubuntu/tk_trial/LSTM/results/cross_subject/groupbeta_1.nii.gz'
group = image.load_img(group_fname)
group1_surf_R = surface.vol_to_surf(group, fsaverage.pial_right)
group1_surf_L = surface.vol_to_surf(group, fsaverage.pial_left)
group_fname = '/home/ubuntu/tk_trial/LSTM/results/cross_subject/groupbeta_2.nii.gz'
group = image.load_img(group_fname)
group2_surf_R = surface.vol_to_surf(group, fsaverage.pial_right)
group2_surf_L = surface.vol_to_surf(group, fsaverage.pial_left)
group_fname = '/home/ubuntu/tk_trial/LSTM/results/cross_subject/groupbeta_3.nii.gz'
group = image.load_img(group_fname)
group3_surf_R = surface.vol_to_surf(group, fsaverage.pial_right)
group3_surf_L = surface.vol_to_surf(group, fsaverage.pial_left)
# %%
# outline
# TPJ outline _____________________________________________________________________________________
action_uniformity_fname = '/home/ubuntu/feature-encoding/viz/brain_plot/action_uniformity-test_z_FDR_0.01.nii.gz'
neurosynth_thres = 0.
thres = 1.
fig, axes = plt.subplots(1,1,subplot_kw={'projection':'3d'}, figsize=(9, 6))
plotting.plot_surf_stat_map(fsaverage.infl_right, group0_surf_R, hemi='right',
title='Surface right hemisphere', colorbar=True,
threshold=1., bg_map=fsaverage.sulc_right,
figure = fig, axes=axes)
plotting.show()
# c = plotting.plot_surf(fsaverage.infl_right,empathy_rev_surf_R, hemi='right',
# title='Surface right hemisphere',
# bg_map=fsaverage.sulc_right, alpha = alpha_thres, threshold = thres,
# cmap = 'BuPu_r', figure = fig, axes=axes, avg_method = 'median')
action_ns = image.threshold_img(action_uniformity_fname,
threshold=neurosynth_thres,
copy=False)
texture = surface.vol_to_surf(action_ns, fsaverage.pial_right)
# plotting.plot_surf_stat_map(fsaverage.infl_right, texture, hemi='right',
# title='Surface right hemisphere', colorbar=False,
# bg_map=fsaverage.sulc_right, alpha = 0., threshold=thres,
# figure = fig, axes=axes)
# https://mjboos.github.io/Nilearn-surface-contours/
# coords, faces = surface.load_surf_mesh(fsaverage.infl_right)
# load vertex coordinates and face indices that specify the surface mesh
coords, faces = load_surf_mesh(fsaverage.infl_right)
destrieux_atlas = datasets.fetch_atlas_surf_destrieux()
parcellation = destrieux_atlas['map_right']
# these are the regions we want to outline
regions = [b'G_pariet_inf-Angular',
b'G_precentral', b'G_postcentral']
regions_idx = [np.where( | np.array(destrieux_atlas['labels']) | numpy.array |
import pandas as pd
import numpy as np
import datetime
from sklearn.utils.class_weight import compute_sample_weight
from termcolor import colored
from tqdm import tqdm
np.random.seed(1)
DISTANCE=60
TIMESTEP_SIZE=60
BATCH_SIZE=256
TEST_RATIO=0.25
PRINT_DATA_EACH=50
TEST_EACH=PRINT_DATA_EACH*10
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--test', action='store_true')
args = parser.parse_args()
df=pd.read_csv("bitstampUSD_1-min_data_2012-01-01_to_2019-03-13.csv")
split_date="01/01/2017"
split_timestamp=datetime.datetime.strptime(split_date, "%d/%m/%Y").timestamp()
data=[]
c=0
last_d=None
for d in df.values:
if d[0]>=split_timestamp and (not np.isnan(d[4])):
if np.isnan(d[4]):
data.append(last_d[4])
else:
last_d=d
data.append(d[4])
split_index=int(len(data)*TEST_RATIO)
train_data=np.array(data[:-split_index])
test_data=np.array(data[-split_index:])
def get_x(data,start_index):
sampled_x=np.expand_dims(data[start_index:start_index+TIMESTEP_SIZE],axis=1)
sampled_x=(sampled_x/(sampled_x[0]+1e-8))-1 #the normalization step
return sampled_x
def get_y(data,start_index):
seq=data[start_index+TIMESTEP_SIZE:start_index+TIMESTEP_SIZE+DISTANCE]
st_p=seq[0]
y_ = np.mean(seq) / st_p
return int(y_>1)
ys_train_data_is={0:[],1:[]}
for i in tqdm(range(len(train_data)-TIMESTEP_SIZE-DISTANCE),desc='ys_train_data_is'):
y_=get_y(train_data,i)
ys_train_data_is[y_].append(i)
total_=sum(map(len,ys_train_data_is.values()))
print(" , ".join(["{}:{:.5%}".format(key,len(value)/total_) for key,value in ys_train_data_is.items()]))
def generator(data,BATCH_SIZE):
while True:
start_index_0=np.random.choice(ys_train_data_is[0],size=BATCH_SIZE//2)
start_index_1=np.random.choice(ys_train_data_is[1],size=BATCH_SIZE//2)
x=[]
y=[]
for start_index in np.append(start_index_0,start_index_1):
sampled_y=get_y(data,start_index)
sampled_x=get_x(data,start_index)
x.append(sampled_x)
y.append(sampled_y)
yield np.array(x),np.array(y)
def get_sample_weight(y):
return compute_sample_weight("balanced",y)
from keras import backend as K
###################################################
#This code is to limit the amount of gpu memory that the model use for training
config = K.tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.3
sess = K.tf.Session(config=config)
K.set_session(sess)
###################################################
from keras.models import Model,load_model
from keras import layers as kl
from keras import optimizers
def average_pred(y_true,y_pred):
return K.mean(y_pred)
li=kl.Input(shape=(TIMESTEP_SIZE,1))
l=li
for n_units in [16,32,64,128]:
l=kl.Conv1D(n_units,3,activation='elu',padding='same')(l)
l=kl.MaxPooling1D()(l)
l=kl.Flatten()(l)
l=kl.Dense(64,activation='elu')(l)
l=kl.Dense(1,activation='sigmoid')(l)
model=Model(li,l)
model.compile(optimizers.Adamax(lr=0.002),"binary_crossentropy",['acc',average_pred])
if not args.test:
from keras.callbacks import TensorBoard
import os
iteration=0
res=[]
print_msg="iteration: {} : loss: {:.6f}, acc: {:.4%}, avg_pred: {:.4f}, avg_y: {:.4f}, left_iter_to_test: {}"
best_score=np.inf
for filename in os.listdir("./logs"):
os.remove("./logs/{}".format(filename))
tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,batch_size=BATCH_SIZE,
write_graph=True, write_images=False)
tensorboard.set_model(model)
for x,y in generator(train_data,BATCH_SIZE):
r=model.train_on_batch(x,y)
tensorboard.on_epoch_end(iteration,{'train_loss':r[0],'train_acc':r[1]})
r+=[np.mean(y)]
res.append(r)
iteration+=1
if iteration%PRINT_DATA_EACH==0:
print(print_msg.format(iteration,*np.mean(res,axis=0), TEST_EACH-((iteration-1)%TEST_EACH)))
res=[]
if iteration%(TEST_EACH)==0:
true=[]
test=[]
for i in tqdm(range(len(test_data)-TIMESTEP_SIZE-DISTANCE),desc="testing"):
test.append(get_x(test_data,i))
true.append(get_y(test_data,i))
true,test=np.array(true),np.array(test)
pred=model.evaluate(test,true,sample_weight=get_sample_weight(true),verbose=1,batch_size=BATCH_SIZE)
msg=''
if best_score>pred[0]:
best_score=pred[0]
model.save("model.h5")
msg+=", FOUND A NEW SCORE"
tensorboard.on_epoch_end(iteration,{'test_loss':pred[0],'test_acc':pred[1]})
print(colored("res: {}{}".format( | np.array(pred) | numpy.array |
from autodiff import variable
from autodiff.utils import get_vars
import numpy as np
import math
class Function():
def __init__(self, dim:int, *args):
self.func = [None] * dim
self.dim = dim
vars = []
for v in args:
vars.append(v)
self.vars = vars
def eval(self, **kwargs):
"""
evaluate at given environment
param:
kwargs : variable-values should be given, default 1
return:
value-vector (1d numpy array)
"""
res = np.zeros(self.dim)
env = {}
for var in self.vars:
env[var] = kwargs.get(var, 1)
for i in range(0, self.dim):
res[i] = self.func[i].eval(**env)
return res
def autodiff(self, var:str, **kwargs):
"""
calculates gradient for var at given envirnment
param:
var : variable-name to calculate derivative for, e.g. "x"
kwargs : variable-values should be given, default 1
return:
gradiant-vector (1d numpy array)
"""
res = np.zeros(self.dim)
env = {}
for var in self.vars:
env[var] = kwargs.get(var, 1)
for i in range(0, self.dim):
res[i] = self.func[i].autodiff(var, **env)
return res
def jacobian(self, **kwargs):
"""
calculates Jacobian-Matrix at given env
param:
kwargs : variable-values should be given, default 1
return:
jacobian-matrix (2d numpy array)
"""
env = {}
for var in self.vars:
env[var] = kwargs.get(var, 1)
jac = np.zeros((self.dim, len(self.vars)), dtype="float32")
for i in range(0, self.dim):
for j in range(0, len(self.vars)):
jac[i,j] = self.func[i].autodiff(self.vars[j], **env)
return jac
def variance(self, covmat, pos):
"""
calculates covarianz-matrix for values
param:
covmat : covariance-matrix for input variables as numpy array
pos : space-vector (in order of variables, given as 1d numpy array)
return:
covarainz-matrix (2d numpy array)
"""
env = {}
for i in range(0, len(self.vars)):
env[self.vars[i]] = pos[i]
jac = self.jacobian(**env)
return np.matmul(np.matmul(jac, covmat), np.transpose(jac))
def covar_from_val(self, values):
"""
calculates covarianz-matrix for values
param:
value : 2d numpy array, rows correspond to one dataset, columns in order of variables
return:
covarainz-matrix (2d numpy array)
"""
cov = cross_covariance(values)
env = {}
m = np.sum(values, axis=0) / values.shape[0]
for i in range(0, len(self.vars)):
env[self.vars[i]] = m[i]
jac = self.jacobian(**env)
return np.matmul(np.matmul(jac, cov), np.transpose(jac))
def vars(self):
return self.vars
def __getitem__(self, key):
if key < 0 or key > self.dim:
raise ValueError("index out of range")
return self.func[key]
def __setitem__(self, key, value):
if key < 0 or key > self.dim:
raise ValueError("index out of range")
for var in get_vars(value):
if var not in self.vars:
raise ValueError("variale mismatch")
self.func[key] = value
def __str__(self):
s = "[ " + self.func[0].__str__() + "\n"
for i in range(1, self.dim-1):
s += " " + self.func[i].__str__() + "\n"
s += " " + self.func[self.dim-1].__str__() + " ]"
return s
def cross_covariance(valuematrix):
"""
calculates cross covariance matrix from value matrix
param:
valuematrix: rows correspond to datasets, columns to variables
returns:
covariance matrix as numpy array
"""
s = valuematrix.shape
if len(s) > 2 or len(s) < 0:
raise ValueError("wrong value_matrix format")
m = np.sum(valuematrix, axis=0) / s[0]
v = valuematrix - m
cov = np.matmul( | np.transpose(v) | numpy.transpose |
import unittest
import numpy as np
from sklearn.metrics.pairwise import pairwise_distances_argmin_min
from clusterz.algs.kzmedian import (
DistributedKZMedian, BELDistributedKMedian, k_median_my, kz_median, KZMedian, KMedianWrapped
)
class MyTestCase(unittest.TestCase):
def setUp(self):
cluster = np.random.uniform(-1, 1, size=(40, 2))
self.centers_ = np.array([
[0, 30], [0, -30]
])
self.outliers_ = np.array([
[80, 0], [-80, 0]
])
# data set on a single machine
self.X_without_outliers_ = np.vstack(
[self.centers_,
# clusters
cluster + self.centers_[0] + np.array([5, 0]),
cluster + self.centers_[0] + np.array([-5, 0]),
cluster + self.centers_[1] + np.array([5, 0]),
cluster + self.centers_[1] + np.array([-5, 0])])
self.X_with_outliers_ = np.vstack(
[self.centers_,
self.outliers_,
# clusters
cluster + self.centers_[0] + np.array([5, 0]),
cluster + self.centers_[0] + np.array([-5, 0]),
cluster + self.centers_[1] + np.array([5, 0]),
cluster + self.centers_[1] + np.array([-5, 0])])
self.random_weight_without_outliers_ = np.hstack(
[np.ones(2) * 2,
np.random.uniform(1, 2, len(cluster) * 4)])
self.random_weight_ = np.hstack(
[np.ones(2),
np.ones(2),
np.random.uniform(1, 2, len(cluster) * 4)])
self.uniform_weight_ = np.ones(len(self.X_with_outliers_))
# data on 2 machines
self.Xs_without_outliers_ = [
np.vstack(
[self.centers_[0],
# clusters
cluster + self.centers_[0] + np.array([5, 0]),
cluster + self.centers_[1] + np.array([-5, 0])]),
np.vstack(
[self.centers_[1],
# clusters
cluster + self.centers_[0] + | np.array([-5, 0]) | numpy.array |
from __future__ import division
import numpy as np
from numpy import pi, sqrt, exp, power, log, log10
import os
import constants as ct
import particle as pt
import tools as tl
##############################
# Preparing SKA configurations
##############################
def initialize():
"""This routine is supposed to be run only once, \
i.e. when the module is loaded, therefore\
the I/O is not optimized for speed concerns.
"""
SKA_conf = {}
# # --------------
for exper in ['low', 'mid']:
# if exper == "low":
# path = local_path + "/data/SKA1-low_accumu.csv"
# elif exper == "mid":
# path = local_path + "/data/SKA1-mid_accumu.csv"
# data_raw = np.loadtxt(path, delimiter=',')
# radius = data_raw[:, 0]
# fraction = data_raw[:, 1]
# bins_radius = np.logspace(1, 5, 20) # bin it
# hist_radius = np.interp(np.log10(bins_radius), np.log10(
# radius), fraction, left=0) # sample at the bin edges
# if exper == "low":
# # compute the x-y coordinates of all units
# x_arr, y_arr = get_telescope_coordinate(
# fraction*ct._SKALow_number_of_stations_, radius, SKA=exper)
# # save it
# SKA_conf['low radius'] = (data_raw, x_arr, y_arr, bins_radius,
# hist_radius)
# elif exper == "mid":
# x_arr, y_arr = get_telescope_coordinate(
# fraction*ct._SKA1Mid_number_of_dishes_, radius, SKA=exper)
# SKA_conf['mid radius'] = (data_raw, x_arr, y_arr, bins_radius,
# hist_radius)
# get coordinates
if exper == "low":
SKA_conf['low0'] = np.loadtxt(
local_path + "/data/SKA1_config_low0.csv", delimiter=',')
SKA_conf['low1'] = np.loadtxt(
local_path + "/data/SKA1_config_low1.csv", delimiter=',')
SKA_conf['low2'] = np.loadtxt(
local_path + "/data/SKA1_config_low2_6clusters.csv", delimiter=',')
# update clusters, it's 6 stations per cluster
new_arr = []
for xy in (SKA_conf['low2']):
for j in range(2):
for k in range(3):
x = xy[0] + j*50
y = xy[1] + (k-1)*50
new_arr.append([x, y])
new_arr = np.array(new_arr)
SKA_conf['low2'] = new_arr
# combine them
SKA_conf['low_coord'] = np.concatenate(
(SKA_conf['low0'], SKA_conf['low1'], SKA_conf['low2']))
x_arr = SKA_conf['low_coord'][:, 0]
y_arr = SKA_conf['low_coord'][:, 1]
elif exper == "mid":
SKA_conf['mid0_MeerKAT'] = np.loadtxt(
local_path + "/data/SKA1_config_mid0_MK.csv", delimiter=',')
SKA_conf['mid0_SKA'] = np.loadtxt(
local_path + "/data/SKA1_config_mid0_SKA.csv", delimiter=',')
SKA_conf['mid1_MeerKAT'] = np.loadtxt(
local_path + "/data/SKA1_config_mid1_MK.csv", delimiter=',')
SKA_conf['mid1_SKA'] = np.loadtxt(
local_path + "/data/SKA1_config_mid1_SKA.csv", delimiter=',')
SKA_conf['mid2_SKA'] = np.loadtxt(
local_path + "/data/SKA1_config_mid2_SKA.csv", delimiter=',')
# combine them
SKA_conf['mid_coord'] = np.concatenate(
(SKA_conf['mid0_MeerKAT'],
SKA_conf['mid0_SKA'],
SKA_conf['mid1_MeerKAT'],
SKA_conf['mid1_SKA'],
SKA_conf['mid2_SKA']))
# convert km to m
SKA_conf['mid_coord'][:, 0] = SKA_conf['mid_coord'][:, 0]*1.e3
SKA_conf['mid_coord'][:, 1] = SKA_conf['mid_coord'][:, 1]*1.e3
x_arr = SKA_conf['mid_coord'][:, 0]
y_arr = SKA_conf['mid_coord'][:, 1]
# get baseline distribution
baseline_arr = get_baseline(x_arr, y_arr)
hist_baseline, bins_baseline = np.histogram(
baseline_arr, bins=np.logspace(1, 5, 20000))
# correcting the over-counting of baseline pair
hist_baseline = hist_baseline/2.
hist_baseline_cumsum = np.cumsum(hist_baseline)
# save it
if exper == "low":
SKA_conf['low baseline'] = (
baseline_arr, hist_baseline, bins_baseline, hist_baseline_cumsum)
elif exper == "mid":
SKA_conf['mid baseline'] = (
baseline_arr, hist_baseline, bins_baseline, hist_baseline_cumsum)
# about effective area
if exper == "low":
path = local_path + "/data/SKA1-low_Aeff_over_Tsys.txt"
data_raw = np.loadtxt(path)
# low is given in MHz, convert to GHz
data_raw[:, 0] = data_raw[:, 0] * 1.e-3
SKA_conf['low A/T'] = data_raw
elif exper == "mid":
path = local_path + "/data/SKA1-mid_Aeff_over_Tsys.txt"
data_raw = np.loadtxt(path)
SKA_conf['mid A/T'] = data_raw
SKA_conf['A/T'] = np.concatenate((SKA_conf['low A/T'],
SKA_conf['mid A/T']))
# computing efficiency
# make a nu grid
Nsteps = 2001
nulow = np.logspace(log10(ct._nu_min_ska_low_), log10(
ct._nu_max_ska_low_), Nsteps//2)[1:]
# ... and SKA mid...
numid = np.logspace(log10(ct._nu_min_ska_mid_), log10(
ct._nu_max_ska_mid_), Nsteps - Nsteps//2)[1:]
Aeff_over_Tsys = SKA_conf['A/T']
# Mid
nu_arr = numid
Aeff_over_Tsys_arr = np.interp(
nu_arr, Aeff_over_Tsys[:, 0], Aeff_over_Tsys[:, 2])
Tsys_arr = T_sys_mid(nu_arr)
eta_arr = Aeff_over_Tsys_arr * Tsys_arr / ct._area_ska_mid_
SKA_conf['eta mid'] = (nu_arr, eta_arr)
# Low
nu_arr = nulow
Aeff_over_Tsys_arr = np.interp(
nu_arr, Aeff_over_Tsys[:, 0], Aeff_over_Tsys[:, 2])
Tsys_arr = T_sys_low(nu_arr)
eta_arr = Aeff_over_Tsys_arr * Tsys_arr / ct._area_ska_low_
SKA_conf['eta low'] = (nu_arr, eta_arr)
# combined storage
nu_arr = np.concatenate((SKA_conf['eta low'][0], SKA_conf['eta mid'][0]))
eta_arr = np.concatenate((SKA_conf['eta low'][1], SKA_conf['eta mid'][1]))
SKA_conf['eta'] = (nu_arr, eta_arr)
return SKA_conf
################
# SKA properties
################
def SKA_get_active_baseline(length, exper_mode):
"""Get the active number of baselines in the interferometry mode
:param length: critical baseline below which the signal can be resolved
:param exper_mode: "SKA low" or "SKA mid"
:returns: number of baselines that sees the signal
"""
length_arr, is_scalar = tl.treat_as_arr(length)
if exper_mode == "SKA low":
(baseline_arr, hist_baseline, bins_baseline,
hist_baseline_cumsum) = SKA_conf['low baseline']
if exper_mode == "SKA mid":
(baseline_arr, hist_baseline, bins_baseline,
hist_baseline_cumsum) = SKA_conf['mid baseline']
res = np.interp(np.log(length_arr), np.log(bins_baseline[:-1]),
hist_baseline_cumsum, left=ct._zero_)
if exper_mode == "SKA low":
res[length_arr < ct._SKALow_station_diameter_] = ct._zero_
if exper_mode == "SKA mid":
res[length_arr < ct._SKA1Mid_dish_diameter_] = ct._zero_
if is_scalar:
res = np.squeeze(res)
return res
def SKA_exper_nu(nu):
"""
Returns the SKA experiment mode (low/mid) sensitive to the given frequency nu [GHz].
Parameters
----------
nu : frequency [GHz]
"""
if (nu < ct._nu_min_ska_low_): # frequency below SKA low lower threshold
exper_mode = None # just a placeholder, won't matter
elif (nu <= ct._nu_max_ska_low_): # frequency within SKA low range
exper_mode = 'SKA low'
elif (nu <= ct._nu_max_ska_mid_): # frequency within SKA mid range
exper_mode = 'SKA mid'
else: # frequency above SKA mid upper threshold
exper_mode = None # just a placeholder, won't matter
return exper_mode
def SKA_specs(nu, exper_mode, correlation_mode=None, theta_sig=None):
"""
Returns the SKA specifications for the given experiment mode and frequency [GHz]:
area [m^2],
window,
receiver noise brightness temperature [K],
efficiency,
solid angle resolution [sr],
number_of_dishes, and
number_of_measurements.
Parameters
----------
nu : frequency [GHz]
exper_mode : mode in which the experiment is working
correlation_mode: whether to run in interferometry mode or single dish mode. Default None is meant to raise error if not assigned explicitly.
theta_sig: the signal size we want to observe [radian]
"""
if exper_mode == None:
area, window, Tr, eta, Omega_res, number_of_dishes, number_of_measurements = 0., 0., 0., 0., 1.e-100, 0., 0. # set to zero so it will raise error if not treated
elif exper_mode == 'SKA low' and correlation_mode == "single dish":
area = ct._area_ska_low_
window = np.heaviside(nu - ct._nu_min_ska_low_, 1.) * \
np.heaviside(ct._nu_max_ska_low_ - nu, 1.)
# Tr = ct._Tr_ska_low_ # DEPRECATED
Tr = Trec_low(nu)
eta = eta_nu(nu)
# finding resolution:
wavelength = pt.lambda_from_nu(nu)/100. # wavelength [m]
# angular size of pixel resolution [rad]
# assuming this is the aperture angle and not the radial angle
theta_res = (1.22*wavelength) / \
ct._SKALow_station_diameter_ # /sqrt(eta)
Omega_res = ct.angle_to_solid_angle(
theta_res) # solid angle of resolution [sr]
number_of_dishes = ct._SKALow_number_of_stations_
number_of_measurements = number_of_dishes
# Omega_max = np.inf # being sloppy here but we never reach FOV
elif exper_mode == 'SKA low' and correlation_mode == "interferometry":
window = np.heaviside(nu - ct._nu_min_ska_low_, 1.) * \
np.heaviside(ct._nu_max_ska_low_ - nu, 1.)
# Tr = ct._Tr_ska_low_ # DEPRECATED
Tr = Trec_low(nu)
eta = eta_nu(nu)
# get the required baseline length for nu
wavelength = pt.lambda_from_nu(nu) / 100. # wavelength [m]
critical_baseline_length = (
1.22*wavelength) / (theta_sig)\
* ct._SKA_factor_lose_signal_ # fudge factor for when invisible
# get the active number of baselines
active_number_of_baselines = SKA_get_active_baseline(
critical_baseline_length, exper_mode='SKA low')
# taking the resolution to be exactly the signal size
# penalty is taken care of through active_number_of_baselines
theta_res = theta_sig
Omega_res = ct.angle_to_solid_angle(
theta_res) # solid angle of resolution [sr]
# for interferometry mode noise has 1/sqrt(number of active baselines)
number_of_measurements = active_number_of_baselines
# NOTE: N.B.: this reception area is the total area, and is correct only assuming all dishes/stations contribute
# which is NOT true for large signal angular size. The code needs to be updated to include the fact that
# only active dishes/stations/telescopes are contributing. Thus, for large signal angular sizes,
# the individual values of the S and N CANNOT BE TRUSTED.
# However, since S and N scale the same with reception area, S/N cancels out
# in the end only the number of measurements (baselines) matter.
# Therefore, our S/N CAN INDEED be trusted.
area = ct._area_ska_low_
number_of_dishes = ct._SKALow_number_of_stations_
elif exper_mode == 'SKA mid' and correlation_mode == "single dish":
area = ct._area_ska_mid_
window = np.heaviside(nu - ct._nu_min_ska_mid_, 0.) * \
np.heaviside(ct._nu_max_ska_mid_ - nu, 1.)
# Tr = ct._Tr_ska_mid_ # DEPRECATED, AND INCONSISTENT
Tr = Trec_mid(nu)
eta = eta_nu(nu)
# finding resolution:
wavelength = pt.lambda_from_nu(nu)/100. # wavelength [m]
# angular size of pixel resolution [rad]
# assuming this is the aperture angle and not the radial angle
# theta_res = (1.22*wavelength)/sqrt(eta*4.*area/pi)
theta_res = (1.22*wavelength)/ct._SKA1Mid_dish_diameter_ # /sqrt(eta)
Omega_res = ct.angle_to_solid_angle(
theta_res) # solid angle of resolution [sr]
number_of_dishes = ct._SKA1Mid_number_of_dishes_
number_of_measurements = number_of_dishes
# Omega_max = np.inf # being sloppy here but we never reach FOV
elif exper_mode == 'SKA mid' and correlation_mode == "interferometry":
area = ct._area_ska_mid_
window = np.heaviside(nu - ct._nu_min_ska_mid_, 0.) * \
np.heaviside(ct._nu_max_ska_mid_ - nu, 1.)
# Tr = ct._Tr_ska_mid_ # DEPRECATED, AND INCONSISTENT
Tr = Trec_mid(nu)
eta = eta_nu(nu)
# get the required baseline length for nu
wavelength = pt.lambda_from_nu(nu) / 100. # wavelength [m]
critical_baseline_length = (
1.22*wavelength) / (theta_sig)\
* ct._SKA_factor_lose_signal_ # fudge factor
# get the active number of baselines
active_number_of_baselines = SKA_get_active_baseline(
critical_baseline_length, exper_mode='SKA mid')
# taking the resolution to be exactly the signal size
# penalty is taken care of through active_num_of_baselines
theta_res = theta_sig
Omega_res = ct.angle_to_solid_angle(
theta_res) # solid angle of resolution [sr]
# for interferometry mode noise has 1/sqrt(number of active baselines)
number_of_measurements = active_number_of_baselines
# NOTE: N.B.: this reception area is the total area, and is correct only assuming all dishes/stations contribute
# which is NOT true for large signal angular size. The code needs to be updated to include the fact that
# only active dishes/stations/telescopes are contributing. Thus, for large signal angular sizes,
# the individual values of the S and N CANNOT BE TRUSTED.
# However, since S and N scale the same with reception area, S/N cancels out
# in the end only the number of measurements (baselines) matter.
# Therefore, our S/N CAN INDEED be trusted.
area = ct._area_ska_mid_
number_of_dishes = ct._SKA1Mid_number_of_dishes_
# in case the number of baselines is zero
if number_of_measurements == 0:
number_of_measurements = 1e-100
return area, window, Tr, eta, Omega_res, number_of_dishes, number_of_measurements
# def get_telescope_coordinate(tel_arr, r_arr, SKA):
# """Generate an array with coordinate of each telescope computed
# :param tele_arr: the array of telescope index from 1 to (number of telescope)
# :param radius_arr: the radius of each telescope
# :param SKA: "low" or "mid"
# """
# if SKA == "low":
# tel_fine_arr = np.arange(ct._SKALow_number_of_stations_)
# r_core = ct._SKALow_r_core_
# elif SKA == "mid":
# tel_fine_arr = np.arange(ct._SKA1Mid_number_of_dishes_)
# r_core = ct._SKA1Mid_r_core_
# r_fine_arr = np.interp(tel_fine_arr, tel_arr, r_arr)
# # fix seed as we don't really need the randomness
# np.random.seed(123)
# theta_arr = np.random.random(size=len(r_fine_arr)) * np.pi * 2.
# # over write the arm part
# # mask = np.where(r_fine_arr > r_core, True, False)
# for i in tel_fine_arr:
# if r_fine_arr[int(i)] > r_core:
# theta_arr[int(i)] = int(i) % 3 * 2. * np.pi / 3.
# x_arr = r_fine_arr * np.cos(theta_arr)
# y_arr = r_fine_arr * np.sin(theta_arr)
# return x_arr, y_arr
def get_baseline(x_arr, y_arr):
"""Given array coordinates x, y, compute lengths of each pair. Returns the array of pair lengths.
:param x_arr: x coordinate of all units
:param y_arr: y coordinates of all units
"""
n_unit = len(x_arr)
# n_baseline = int(n_unit * (n_unit - 1) / 2.)
baseline_arr = np.zeros((n_unit, n_unit))
for i in range(n_unit):
for j in range(n_unit):
# print("x[i]=%s, y[j]=%s" % (x_arr[i], y_arr[j]))
dist = np.sqrt((x_arr[i] - x_arr[j])**2 + (y_arr[i] - y_arr[j])**2)
baseline_arr[i, j] = dist
# baseline_arr[j, i] = dist
baseline_arr = baseline_arr.reshape(-1)
baseline_arr = baseline_arr[baseline_arr > 0]
return baseline_arr
def Trec_mid_MeerKAT(nu):
"""Receiver noise temperature [K] of a MeerKAT dish (13.5m-diameter type)
:param nu: frequency [GHz]
"""
nu, is_scalar = tl.treat_as_arr(nu)
res = []
for nui in nu:
if 0.58 < nui < 1.02:
res.append(11 - 4.5*(nui-0.58))
elif 1.02 < nui < 1.67:
res.append(7.5 + 6.8 * np.abs(nui - 1.65)**1.5)
elif 1.65 < nui < 3.05:
res.append(7.5)
else:
res.append(np.inf)
if is_scalar:
res = np.squeeze(res)
return np.array(res)
def Trec_mid_SKA(nu):
"""Receiver noise temperature [K] of a SKA dish (15m-diameter type)
:param nu: frequency [GHz]
"""
nu, is_scalar = tl.treat_as_arr(nu)
res = []
for nui in nu:
if 0.35 < nui < 0.95:
res.append(15 + 30*(nui-0.75)**2)
elif 0.95 < nui < 4.6:
res.append(7.5)
elif 4.6 < nui < 50:
res.append(4.4+0.69 * nui)
else:
res.append(np.inf)
if is_scalar:
res = np.squeeze(res)
return np.array(res)
def Trec_mid(nu):
"""Receiver noise temperature [K] of a typical SKA1-mid dish. Combines MeerKAT with SKA dishes. If there's only SKA dish, use that one; if there are both, use a weighted mean.
:param nu: frequency [GHz]
"""
nu, is_scalar = tl.treat_as_arr(nu)
Trec_arr = []
for nui in nu:
val1 = Trec_mid_MeerKAT(nui)
val2 = Trec_mid_SKA(nui)
if np.isinf(val1):
val1 = val2
# val = np.sqrt(val1*val2) # NOTE: geometric mean puts them on equal footing, even if there was but a single MeerKAT telescope!!!
val = (val1*64. + val2*133.)/(133.+64.) # weighted mean: seems fairer
Trec_arr.append(val)
Trec_arr = np.array(Trec_arr)
if is_scalar:
Trec_arr = np.squeeze(Trec_arr)
return Trec_arr
def Trec_low(nu):
"""Receiver noise temperature [K] of a typical SKA1-low dish.
:param nu: frequency [GHz]
"""
nu, is_scalar = tl.treat_as_arr(nu)
Trec_arr = np.ones_like(nu) * ct._Tr_ska_low_
if is_scalar:
Trec_arr = | np.squeeze(Trec_arr) | numpy.squeeze |
from gymenv_v2 import make_multiple_env
import numpy as np
import random
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import wandb
wandb.login()
run=wandb.init(project="finalproject", entity="ieor-4575", tags=["test"])
#run=wandb.init(project="finalproject", entity="ieor-4575", tags=["training-hard"])
#run=wandb.init(project="finalproject", entity="ieor-4575", tags=["test"])
### TRAINING
# Setup: You may generate your own instances on which you train the cutting agent.
custom_config = {
"load_dir" : 'instances/randomip_n60_m60', # this is the location of the randomly generated instances (you may specify a different directory)
"idx_list" : list(range(20)), # take the first 20 instances from the directory
"timelimit" : 50, # the maximum horizon length is 50
"reward_type" : 'obj' # DO NOT CHANGE reward_type
}
# Easy Setup: Use the following environment settings. We will evaluate your agent with the same easy config below:
easy_config = {
"load_dir" : 'instances/train_10_n60_m60',
"idx_list" : list(range(10)),
"timelimit" : 50,
"reward_type" : 'obj'
}
# Hard Setup: Use the following environment settings. We will evaluate your agent with the same hard config below:
hard_config = {
"load_dir" : 'instances/train_100_n60_m60',
"idx_list" : list(range(99)),
"timelimit" : 50,
"reward_type" : 'obj'
}
test_config = {
"load_dir" : 'instances/test_100_n60_m60',
"idx_list" : list(range(99)),
"timelimit" : 50,
"reward_type" : 'obj'
}
class LSTM_net(nn.Module):
def __init__(self, input_size, hidden_size, bidirectional=False):
super(LSTM_net, self).__init__()
self.hidden_size = hidden_size
self.input_size = input_size
self.bidirectional = bidirectional
self.lstm = nn.LSTM(input_size, hidden_size,
bidirectional=bidirectional, batch_first=True)
def forward(self, input):
hidden = self.init_hidden()
inputs = torch.FloatTensor(input).view(1, -1, self.input_size)
output, _ = self.lstm(inputs)
# output[-1] is same as last hidden state
output = output[-1].reshape(-1, self.hidden_size)
return output
def init_hidden(self):
return (torch.zeros(1 + int(self.bidirectional), 1, self.hidden_size),
torch.zeros(1 + int(self.bidirectional), 1, self.hidden_size))
class Attention_Net(nn.Module):
def __init__(self, input_size, hidden_size, hidden_size2):
super(Attention_Net, self).__init__()
# constrain and cuts dimension
self.input_size = int(input_size)
self.hidden_size = int(hidden_size)
self.hidden_size2 = int(hidden_size2)
self.lstm1 = LSTM_net(input_size, hidden_size)
self.lstm2 = LSTM_net(input_size, hidden_size)
self.linear1 = nn.Linear(self.hidden_size, self.hidden_size2)
self.linear2 = nn.Linear(self.hidden_size2, self.hidden_size2)
self.tanh = nn.Tanh()
def forward(self, constraints, cuts):
constraints = torch.FloatTensor(constraints)
cuts = torch.FloatTensor(cuts)
# lstm
A_embed = self.lstm1.forward(constraints)
D_embed = self.lstm2.forward(cuts)
# dense
A = self.linear2(self.tanh(self.linear1(A_embed)))
D = self.linear2(self.tanh(self.linear1(D_embed)))
# attention
logits = torch.sum(torch.mm(D, A.T), axis=1)
return logits
# Policy network will just be copied from lab4 and make small modification
class Policy(object):
def __init__(self, input_size, hidden_size, hidden_size2, lr):
self.model = Attention_Net(input_size, hidden_size, hidden_size2)
# DEFINE THE OPTIMIZER
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
def compute_prob(self, constraints, cuts):
constraints = torch.FloatTensor(constraints)
cuts = torch.FloatTensor(cuts)
prob = torch.nn.functional.softmax(self.model(constraints, cuts), dim=-1)
return prob.cpu().data.numpy()
def _to_one_hot(self, y, num_classes):
"""
convert an integer vector y into one-hot representation
"""
scatter_dim = len(y.size())
y_tensor = y.view(*y.size(), -1)
zeros = torch.zeros(*y.size(), num_classes, dtype=y.dtype)
return zeros.scatter(scatter_dim, y_tensor, 1)
def train(self, constraints, cuts, actions, Qs):
"""
states: numpy array (states)
actions: numpy array (actions)
Qs: numpy array (Q values)
"""
actions = torch.LongTensor(actions)
Qs = torch.FloatTensor(Qs)
total_loss = 0
# for a bunch of constraints and cuts, need to go one by one
for i in range(len(constraints)):
curr_constraints = constraints[i]
curr_cuts = cuts[i]
curr_action = actions[i]
# COMPUTE probability vector pi(s) for all s in states
logits = self.model(curr_constraints, curr_cuts)
prob = torch.nn.functional.softmax(logits, dim=-1)
# Compute probaility pi(s,a) for all s,a
action_onehot = self._to_one_hot(curr_action, curr_cuts.shape[0])
prob_selected = torch.sum(prob * action_onehot, axis=-1)
# FOR ROBUSTNESS
prob_selected += 1e-8
loss = -torch.mean(Qs[i] * torch.log(prob_selected))
# BACKWARD PASS
self.optimizer.zero_grad()
loss.backward()
# UPDATE
self.optimizer.step()
total_loss += loss.detach().cpu().data.numpy()
return total_loss
def discounted_rewards(r, gamma):
""" take 1D float array of rewards and compute discounted reward """
discounted_r = | np.zeros_like(r) | numpy.zeros_like |
#
#
# 0=================================0
# | Kernel Point Convolutions |
# 0=================================0
#
#
# ----------------------------------------------------------------------------------------------------------------------
#
# Class handling the test of any model
#
# ----------------------------------------------------------------------------------------------------------------------
#
# <NAME> - 11/06/2018
#
# ----------------------------------------------------------------------------------------------------------------------
#
# Imports and global variables
# \**********************************/
#
# Basic libs
import tensorflow as tf
import numpy as np
from os import makedirs, listdir
from os.path import exists, join
import time
from sklearn.neighbors import KDTree
# PLY reader
from utils.ply import read_ply, write_ply
# Metrics
from utils.metrics import IoU_from_confusions
from sklearn.metrics import confusion_matrix
from tensorflow.python.client import timeline
import json
# ----------------------------------------------------------------------------------------------------------------------
#
# Tester Class
# \******************/
#
class TimeLiner:
def __init__(self):
self._timeline_dict = None
def update_timeline(self, chrome_trace):
# convert crome trace to python dict
chrome_trace_dict = json.loads(chrome_trace)
# for first run store full trace
if self._timeline_dict is None:
self._timeline_dict = chrome_trace_dict
# for other - update only time consumption, not definitions
else:
for event in chrome_trace_dict['traceEvents']:
# events time consumption started with 'ts' prefix
if 'ts' in event:
self._timeline_dict['traceEvents'].append(event)
def save(self, f_name):
with open(f_name, 'w') as f:
json.dump(self._timeline_dict, f)
class ModelTester:
# Initiation methods
# ------------------------------------------------------------------------------------------------------------------
def __init__(self, model, restore_snap=None):
# Tensorflow Saver definition
my_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='KernelPointNetwork')
self.saver = tf.train.Saver(my_vars, max_to_keep=100)
# Create a session for running Ops on the Graph.
on_CPU = False
if on_CPU:
cProto = tf.ConfigProto(device_count={'GPU': 0})
else:
cProto = tf.ConfigProto()
cProto.gpu_options.allow_growth = True
self.sess = tf.Session(config=cProto)
# Init variables
self.sess.run(tf.global_variables_initializer())
# Name of the snapshot to restore to (None if you want to start from beginning)
# restore_snap = join(self.saving_path, 'snapshots/snap-40000')
if (restore_snap is not None):
self.saver.restore(self.sess, restore_snap)
print("Model restored from " + restore_snap)
# Add a softmax operation for predictions
self.prob_logits = tf.nn.softmax(model.logits)
# Test main methods
# ------------------------------------------------------------------------------------------------------------------
def test_classification(self, model, dataset, num_votes=100):
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
# Number of classes predicted by the model
nc_model = model.config.num_classes
# Initiate votes
average_probs = np.zeros((len(dataset.input_labels['test']), nc_model))
average_counts = np.zeros((len(dataset.input_labels['test']), nc_model))
mean_dt = np.zeros(2)
last_display = time.time()
while np.min(average_counts) < num_votes:
# Run model on all test examples
# ******************************
# Initiate result containers
probs = []
targets = []
obj_inds = []
count = 0
while True:
try:
# Run one step of the model
t = [time.time()]
ops = (self.prob_logits, model.labels, model.inputs['object_inds'])
prob, labels, inds = self.sess.run(ops, {model.dropout_prob: 1.0})
t += [time.time()]
# Get probs and labels
probs += [prob]
targets += [labels]
obj_inds += [inds]
count += prob.shape[0]
# Average timing
t += [time.time()]
mean_dt = 0.95 * mean_dt + 0.05 * (np.array(t[1:]) - np.array(t[:-1]))
# Display
if (t[-1] - last_display) > 1.0:
last_display = t[-1]
message = 'Vote {:.0f} : {:.1f}% (timings : {:4.2f} {:4.2f})'
print(message.format(np.min(average_counts),
100 * count / dataset.num_test,
1000 * (mean_dt[0]),
1000 * (mean_dt[1])))
except tf.errors.OutOfRangeError:
break
# Average votes
# *************
# Stack all validation predictions
probs = np.vstack(probs)
targets = np.hstack(targets)
obj_inds = np.hstack(obj_inds)
if np.any(dataset.input_labels['test'][obj_inds] != targets):
raise ValueError('wrong object indices')
# Compute incremental average (predictions are always ordered)
average_counts[obj_inds] += 1
average_probs[obj_inds] += (probs - average_probs[obj_inds]) / (average_counts[obj_inds])
# Save/Display temporary results
# ******************************
test_labels = np.array(dataset.label_values)
# Compute classification results
C1 = confusion_matrix(dataset.input_labels['test'],
np.argmax(average_probs, axis=1),
test_labels)
ACC = 100 * np.sum(np.diag(C1)) / (np.sum(C1) + 1e-6)
print('Test Accuracy = {:.1f}%'.format(ACC))
s = ''
for cc in C1:
for c in cc:
s += '{:d} '.format(c)
s += '\n'
print(s)
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
return
def test_segmentation(self, model, dataset, num_votes=100, num_saves=10):
##################
# Pre-computations
##################
print('Preparing test structures')
t1 = time.time()
# Collect original test file names
original_path = join(dataset.path, 'test_ply')
object_name = model.config.dataset.split('_')[1]
test_names = [f[:-4] for f in listdir(original_path) if f[-4:] == '.ply' and object_name in f]
test_names = np.sort(test_names)
original_labels = []
original_points = []
projection_inds = []
for i, cloud_name in enumerate(test_names):
# Read data in ply file
data = read_ply(join(original_path, cloud_name + '.ply'))
points = np.vstack((data['x'], -data['z'], data['y'])).T
original_labels += [data['label'] - 1]
original_points += [points]
# Create tree structure and compute neighbors
tree = KDTree(dataset.test_points[i])
projection_inds += [np.squeeze(tree.query(points, return_distance=False))]
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
##########
# Initiate
##########
# Test saving path
if model.config.saving:
test_path = join('test', model.saving_path.split('/')[-1])
if not exists(test_path):
makedirs(test_path)
else:
test_path = None
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
# Initiate result containers
average_predictions = [np.zeros((1, 1), dtype=np.float32) for _ in test_names]
#####################
# Network predictions
#####################
mean_dt = np.zeros(2)
last_display = time.time()
for v in range(num_votes):
# Run model on all test examples
# ******************************
# Initiate result containers
all_predictions = []
all_labels = []
all_points = []
all_scales = []
all_rots = []
while True:
try:
# Run one step of the model
t = [time.time()]
ops = (self.prob_logits,
model.labels,
model.inputs['in_batches'],
model.inputs['points'],
model.inputs['augment_scales'],
model.inputs['augment_rotations'])
preds, labels, batches, points, s, R = self.sess.run(ops, {model.dropout_prob: 1.0})
t += [time.time()]
# Stack all predictions for each class separately
max_ind = np.max(batches)
for b_i, b in enumerate(batches):
# Eliminate shadow indices
b = b[b < max_ind - 0.5]
# Get prediction (only for the concerned parts)
predictions = preds[b]
# Stack all results
all_predictions += [predictions]
all_labels += [labels[b]]
all_points += [points[0][b]]
all_scales += [s[b_i]]
all_rots += [R[b_i, :, :]]
# Average timing
t += [time.time()]
mean_dt = 0.95 * mean_dt + 0.05 * (np.array(t[1:]) - np.array(t[:-1]))
# Display
if (t[-1] - last_display) > 1.0:
last_display = t[-1]
message = 'Vote {:d} : {:.1f}% (timings : {:4.2f} {:4.2f})'
print(message.format(v,
100 * len(all_predictions) / len(original_labels),
1000 * (mean_dt[0]),
1000 * (mean_dt[1])))
except tf.errors.OutOfRangeError:
break
# Project predictions on original point clouds
# ********************************************
print('\nGetting test confusions')
t1 = time.time()
proj_predictions = []
Confs = []
for i, cloud_name in enumerate(test_names):
# Interpolate prediction from current positions to original points
proj_predictions += [all_predictions[i][projection_inds[i]]]
# Average prediction across votes
average_predictions[i] = average_predictions[i] + (proj_predictions[i] - average_predictions[i]) / (v + 1)
# Compute confusion matrices
parts = [j for j in range(proj_predictions[i].shape[1])]
Confs += [confusion_matrix(original_labels[i], np.argmax(average_predictions[i], axis=1), parts)]
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
# Save the best/worst segmentations per class
# *******************************************
print('Saving test examples')
t1 = time.time()
# Regroup confusions per object class
Confs = np.stack(Confs)
IoUs = IoU_from_confusions(Confs)
mIoUs = np.mean(IoUs, axis=-1)
# Get X best and worst prediction
order = np.argsort(mIoUs)
worst_inds = order[:num_saves]
best_inds = order[:-num_saves-1:-1]
worst_IoUs = IoUs[order[:num_saves]]
best_IoUs = IoUs[order[:-num_saves-1:-1]]
# Save the names in a file
obj_path = join(test_path, object_name)
if not exists(obj_path):
makedirs(obj_path)
worst_file = join(obj_path, 'worst_inds.txt')
best_file = join(obj_path, 'best_inds.txt')
with open(worst_file, "w") as text_file:
for w_i, w_IoUs in zip(worst_inds, worst_IoUs):
text_file.write('{:d} {:s} :'.format(w_i, test_names[w_i]))
for IoU in w_IoUs:
text_file.write(' {:.1f}'.format(100*IoU))
text_file.write('\n')
with open(best_file, "w") as text_file:
for b_i, b_IoUs in zip(best_inds, best_IoUs):
text_file.write('{:d} {:s} :'.format(b_i, test_names[b_i]))
for IoU in b_IoUs:
text_file.write(' {:.1f}'.format(100*IoU))
text_file.write('\n')
# Save the clouds
for i, w_i in enumerate(worst_inds):
filename = join(obj_path, 'worst_{:02d}.ply'.format(i+1))
preds = np.argmax(average_predictions[w_i], axis=1).astype(np.int32)
write_ply(filename,
[original_points[w_i], original_labels[w_i], preds],
['x', 'y', 'z', 'gt', 'pre'])
for i, b_i in enumerate(best_inds):
filename = join(obj_path, 'best_{:02d}.ply'.format(i+1))
preds = np.argmax(average_predictions[b_i], axis=1).astype(np.int32)
write_ply(filename,
[original_points[b_i], original_labels[b_i], preds],
['x', 'y', 'z', 'gt', 'pre'])
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
# Display results
# ***************
print('Objs | Inst | Air Bag Cap Car Cha Ear Gui Kni Lam Lap Mot Mug Pis Roc Ska Tab')
print('-----|------|--------------------------------------------------------------------------------')
s = '---- | ---- | '
for obj in dataset.label_names:
if obj == object_name:
s += '{:5.2f} '.format(100 * np.mean(mIoUs))
else:
s += '---- '
print(s + '\n')
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
return
def test_multi_segmentation(self, model, dataset, num_votes=100, num_saves=10):
##################
# Pre-computations
##################
print('Preparing test structures')
t1 = time.time()
# Collect original test file names
original_path = join(dataset.path, 'test_ply')
test_names = [f[:-4] for f in listdir(original_path) if f[-4:] == '.ply']
test_names = np.sort(test_names)
original_labels = []
original_points = []
projection_inds = []
for i, cloud_name in enumerate(test_names):
# Read data in ply file
data = read_ply(join(original_path, cloud_name + '.ply'))
points = np.vstack((data['x'], -data['z'], data['y'])).T
original_labels += [data['label'] - 1]
original_points += [points]
# Create tree structure to compute neighbors
tree = KDTree(dataset.input_points['test'][i])
projection_inds += [np.squeeze(tree.query(points, return_distance=False))]
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
##########
# Initiate
##########
# Test saving path
if model.config.saving:
test_path = join('test', model.saving_path.split('/')[-1])
if not exists(test_path):
makedirs(test_path)
else:
test_path = None
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
# Initiate result containers
average_predictions = [np.zeros((1, 1), dtype=np.float32) for _ in test_names]
#####################
# Network predictions
#####################
mean_dt = np.zeros(2)
last_display = time.time()
for v in range(num_votes):
# Run model on all test examples
# ******************************
# Initiate result containers
all_predictions = []
all_obj_inds = []
while True:
try:
# Run one step of the model
t = [time.time()]
ops = (self.prob_logits,
model.labels,
model.inputs['super_labels'],
model.inputs['object_inds'],
model.inputs['in_batches'])
preds, labels, obj_labels, o_inds, batches = self.sess.run(ops, {model.dropout_prob: 1.0})
t += [time.time()]
# Stack all predictions for each class separately
max_ind = np.max(batches)
for b_i, b in enumerate(batches):
# Eliminate shadow indices
b = b[b < max_ind - 0.5]
# Get prediction (only for the concerned parts)
obj = obj_labels[b[0]]
predictions = preds[b][:, :model.config.num_classes[obj]]
# Stack all results
all_predictions += [predictions]
all_obj_inds += [o_inds[b_i]]
# Average timing
t += [time.time()]
mean_dt = 0.95 * mean_dt + 0.05 * (np.array(t[1:]) - np.array(t[:-1]))
# Display
if (t[-1] - last_display) > 1.0:
last_display = t[-1]
message = 'Vote {:d} : {:.1f}% (timings : {:4.2f} {:4.2f})'
print(message.format(v,
100 * len(all_predictions) / dataset.num_test,
1000 * (mean_dt[0]),
1000 * (mean_dt[1])))
except tf.errors.OutOfRangeError:
break
# Project predictions on original point clouds
# ********************************************
print('\nGetting test confusions')
t1 = time.time()
for i, probs in enumerate(all_predictions):
# Interpolate prediction from current positions to original points
obj_i = all_obj_inds[i]
proj_predictions = probs[projection_inds[obj_i]]
# Average prediction across votes
average_predictions[obj_i] = average_predictions[obj_i] + \
(proj_predictions - average_predictions[obj_i]) / (v + 1)
Confs = []
for obj_i, avg_probs in enumerate(average_predictions):
# Compute confusion matrices
parts = [j for j in range(avg_probs.shape[1])]
Confs += [confusion_matrix(original_labels[obj_i], np.argmax(avg_probs, axis=1), parts)]
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
# Save the best/worst segmentations per class
# *******************************************
print('Saving test examples')
t1 = time.time()
# Regroup confusions per object class
Confs = np.array(Confs)
obj_mIoUs = []
for l in dataset.label_values:
# Get confusions for this object
obj_inds = np.where(dataset.input_labels['test'] == l)[0]
obj_confs = np.stack(Confs[obj_inds])
# Get IoU
obj_IoUs = IoU_from_confusions(obj_confs)
obj_mIoUs += [np.mean(obj_IoUs, axis=-1)]
# Get X best and worst prediction
order = np.argsort(obj_mIoUs[-1])
worst_inds = obj_inds[order[:num_saves]]
best_inds = obj_inds[order[:-num_saves-1:-1]]
worst_IoUs = obj_IoUs[order[:num_saves]]
best_IoUs = obj_IoUs[order[:-num_saves-1:-1]]
# Save the names in a file
obj_path = join(test_path, dataset.label_to_names[l])
if not exists(obj_path):
makedirs(obj_path)
worst_file = join(obj_path, 'worst_inds.txt')
best_file = join(obj_path, 'best_inds.txt')
with open(worst_file, "w") as text_file:
for w_i, w_IoUs in zip(worst_inds, worst_IoUs):
text_file.write('{:d} {:s} :'.format(w_i, test_names[w_i]))
for IoU in w_IoUs:
text_file.write(' {:.1f}'.format(100*IoU))
text_file.write('\n')
with open(best_file, "w") as text_file:
for b_i, b_IoUs in zip(best_inds, best_IoUs):
text_file.write('{:d} {:s} :'.format(b_i, test_names[b_i]))
for IoU in b_IoUs:
text_file.write(' {:.1f}'.format(100*IoU))
text_file.write('\n')
# Save the clouds
for i, w_i in enumerate(worst_inds):
filename = join(obj_path, 'worst_{:02d}.ply'.format(i+1))
preds = np.argmax(average_predictions[w_i], axis=1).astype(np.int32)
write_ply(filename,
[original_points[w_i], original_labels[w_i], preds],
['x', 'y', 'z', 'gt', 'pre'])
for i, b_i in enumerate(best_inds):
filename = join(obj_path, 'best_{:02d}.ply'.format(i+1))
preds = np.argmax(average_predictions[b_i], axis=1).astype(np.int32)
write_ply(filename,
[original_points[b_i], original_labels[b_i], preds],
['x', 'y', 'z', 'gt', 'pre'])
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
# Display results
# ***************
objs_average = [np.mean(mIoUs) for mIoUs in obj_mIoUs]
instance_average = np.mean(np.hstack(obj_mIoUs))
class_average = np.mean(objs_average)
print('Objs | Inst | Air Bag Cap Car Cha Ear Gui Kni Lam Lap Mot Mug Pis Roc Ska Tab')
print('-----|------|--------------------------------------------------------------------------------')
s = '{:4.1f} | {:4.1f} | '.format(100 * class_average, 100 * instance_average)
for AmIoU in objs_average:
s += '{:4.1f} '.format(100 * AmIoU)
print(s + '\n')
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
return
def test_cloud_segmentation(self, model, dataset, num_votes=100):
##########
# Initiate
##########
# Smoothing parameter for votes
test_smooth = 0.98
# Initialise iterator with train data
self.sess.run(dataset.test_init_op)
# Initiate global prediction over test clouds
nc_model = model.config.num_classes
self.test_probs = [np.zeros((l.data.shape[0], nc_model), dtype=np.float32) for l in dataset.input_trees['test']]
# Test saving path
if model.config.saving:
test_path = join('/raid/workspace/fan/res/SH/test', model.saving_path.split('/')[-1])
if not exists(test_path):
makedirs(test_path)
if not exists(join(test_path, 'predictions')):
makedirs(join(test_path, 'predictions'))
if not exists(join(test_path, 'probs')):
makedirs(join(test_path, 'probs'))
else:
test_path = None
#####################
# Network predictions
#####################
options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
many_runs_timeline = TimeLiner()
i0 = 0
epoch_ind = 0
last_min = -0.5
mean_dt = np.zeros(2)
last_display = time.time()
while last_min < num_votes:
try:
# Run one step of the model.
t = [time.time()]
ops = (self.prob_logits,
model.labels,
model.inputs['in_batches'],
model.inputs['point_inds'],
model.inputs['cloud_inds'])
stacked_probs, labels, batches, point_inds, cloud_inds = self.sess.run(ops,
{model.dropout_prob: 1.0})
"""
stacked_probs, labels, batches, point_inds, cloud_inds = self.sess.run(ops,
{model.dropout_prob: 1.0},
options=options,
run_metadata=run_metadata)
"""
t += [time.time()]
#fetched_timeline = timeline.Timeline(run_metadata.step_stats)
#chrome_trace = fetched_timeline.generate_chrome_trace_format()
#many_runs_timeline.update_timeline(chrome_trace)
if False:
many_runs_timeline.save('timeline_merged_%d_runs.json' % i0)
a = 1/0
# Get predictions and labels per instance
# ***************************************
# Stack all predictions for each class separately
max_ind = np.max(batches)
for b_i, b in enumerate(batches):
# Eliminate shadow indices
b = b[b < max_ind - 0.5]
# Get prediction (only for the concerned parts)
probs = stacked_probs[b]
inds = point_inds[b]
c_i = cloud_inds[b_i]
# Update current probs in whole cloud
self.test_probs[c_i][inds] = test_smooth * self.test_probs[c_i][inds] + (1-test_smooth) * probs
# Average timing
t += [time.time()]
#print(batches.shape, stacked_probs.shape, 1000*(t[1] - t[0]), 1000*(t[2] - t[1]))
mean_dt = 0.95 * mean_dt + 0.05 * (np.array(t[1:]) - np.array(t[:-1]))
# Display
if (t[-1] - last_display) > 1.0:
last_display = t[-1]
message = 'Epoch {:3d}, step {:3d} (timings : {:4.2f} {:4.2f}). min potential = {:.1f}'
print(message.format(epoch_ind,
i0,
1000 * (mean_dt[0]),
1000 * (mean_dt[1]),
np.min(dataset.min_potentials['test'])))
i0 += 1
except tf.errors.OutOfRangeError:
# Save predicted cloud
new_min = np.min(dataset.min_potentials['test'])
print('Epoch {:3d}, end. Min potential = {:.1f}'.format(epoch_ind, new_min))
print([np.mean(pots) for pots in dataset.potentials['test']])
if last_min + 2 < new_min:
print('Saving clouds')
# Update last_min
last_min = new_min
# Project predictions
print('\nReproject Vote #{:d}'.format(int( | np.floor(new_min) | numpy.floor |
import argparse
import os, time, datetime
import torch
from torch import nn
import torchvision
import numpy as np
import cv2
import scipy.io
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter
import torch_geometric.data
import neural_renderer as nr
import dataio
import data_util
import util
import metric
import network
import render
import misc
import sph_harm
parser = argparse.ArgumentParser()
# general
parser.add_argument('--data_root', required=True,
help='Path to directory that holds the object data. See dataio.py for directory structure etc..')
parser.add_argument('--logging_root', type=str, default=None, required=False,
help='Path to directory where to write tensorboard logs and checkpoints.')
# mesh
parser.add_argument('--calib_fp', type=str, default='_/calib.mat', required=False,
help='Path of calibration file.')
parser.add_argument('--calib_format', type=str, default='convert', required=False,
help='Format of calibration file')
parser.add_argument('--obj_high_fp', type=str, default='_/mesh.obj', required=False,
help='Path of high-resolution mesh obj.')
parser.add_argument('--obj_low_fp', type=str, default='_/mesh_7500v.obj', required=False,
help='Path of low-resolution mesh obj.')
parser.add_argument('--obj_gcn_fp', type=str, default='_/mesh_7500v.obj', required=False,
help='Path of mesh obj for gcn.')
parser.add_argument('--tex_fp', type=str, default='_/tex.png', required=False,
help='Path of texture.')
# view datasets
parser.add_argument('--img_size', type=int, default=512,
help='Sidelength of generated images. Default 512. Only less than native resolution of images is recommended.')
parser.add_argument('--img_gamma', type=float, default=1.0,
help='Image gamma.')
# texture mapper
parser.add_argument('--texture_size', type=int, default=512,
help='Sidelength of neural texture. Default 512.')
parser.add_argument('--texture_num_ch', type=int, default=24,
help='Number of channels for neural texture. Default 24.')
parser.add_argument('--mipmap_level', type=int, default=4, required=False,
help='Mipmap levels for neural texture. Default 4.')
parser.add_argument('--init_tex', default=False, type = lambda x: (str(x).lower() in ['true', '1']),
help='Whether initialize neural texture using reconstructed texture.')
parser.add_argument('--fix_tex', default=False, type = lambda x: (str(x).lower() in ['true', '1']),
help='Whether fix neural texture.')
parser.add_argument('--apply_sh', default=True, type = lambda x: (str(x).lower() in ['true', '1']),
help='Whether apply spherical harmonics to sampled feature maps. Default True.')
# lighting
parser.add_argument('--lp_dir', type=str, default=None, required=False,
help='Path to directory that holds the light probe data.')
parser.add_argument('--sphere_samples_fp', type = str, default='./sphere_samples_4096.mat', required=False,
help='Path to sphere samples.')
parser.add_argument('--sh_lmax', type = int, default=10, required=False,
help='Maximum degrees of SH basis for lighting.')
parser.add_argument('--fix_lighting', default = False, type = lambda x: (str(x).lower() in ['true', '1']),
help='Whether fix lighting params.')
parser.add_argument('--init_lighting', default=True, type = lambda x: (str(x).lower() in ['true', '1']),
help='Whether initialize lighting params.')
parser.add_argument('--lighting_idx', default = None, type = int,
help='Lighting index for training.')
parser.add_argument('--lighting_relight_idx', default = None, type = int,
help='Lighting index for relighting.')
# rendering net
parser.add_argument('--nf0', type=int, default=64,
help='Number of features in outermost layer of U-Net architectures.')
# gcn
parser.add_argument('--in_channels', default=6, type=int, help='the channel size of input point cloud')
parser.add_argument('--kernel_size', default=16, type=int, help='neighbor num (default:16)')
parser.add_argument('--block_type', default='res', type=str, help='graph backbone block type {res, dense}')
parser.add_argument('--conv_type', default='edge', type=str, help='graph conv layer {edge, mr}')
parser.add_argument('--act_type', default='relu', type=str, help='activation layer {relu, prelu, leakyrelu}')
parser.add_argument('--norm_type', default='batch', type=str, help='batch or instance normalization')
parser.add_argument('--bias', default=True, type=bool, help='bias of conv layer, True or False')
parser.add_argument('--n_filters', default=64, type=int, help='number of channels of deep features')
parser.add_argument('--n_blocks', default=20, type=int, help='number of basic blocks')
parser.add_argument('--epsilon', default=0.2, type=float, help='stochastic epsilon for gcn')
parser.add_argument('--stochastic', default=True, type=bool, help='stochastic for gcn, True or False')
parser.add_argument('--out_channels_gcn', default=512, type=int, help='the channel size of output features')
# losses
parser.add_argument('--loss_lighting_weight', type=float, default=1.0)
parser.add_argument('--loss_lighting_uncovered_weight', type=float, default=0.1)
parser.add_argument('--loss_rays_lt_chrom_weight', type=float, default=1.0)
parser.add_argument('--loss_alb_weight', type=float, default=1.0)
# training
parser.add_argument('--max_epoch', type=int, default=2000, help='Maximum number of epochs to train for.')
parser.add_argument('--max_iter', type=int, default=None, help='Maximum number of iterations to train for.')
parser.add_argument('--lr', type=float, default=0.001, help='Learning rate.')
parser.add_argument('--sampling_pattern', type=str, default='all', required=False)
parser.add_argument('--batch_size', type=int, default=1, help='Batch size.')
# validation
parser.add_argument('--sampling_pattern_val', type=str, default='all', required=False)
parser.add_argument('--val_freq', type=int, default=1000,
help='Test on validation data every X iterations.')
# misc
parser.add_argument('--exp_name', type=str, default='', help='(optional) Name for experiment.')
parser.add_argument('--gpu_id', type=str, default='', help='Cuda visible devices. First device for gcn, last device for the others.')
parser.add_argument('--start_epoch', type=int, default=0, help='Start epoch')
parser.add_argument('--log_freq', type=int, default=100, help='Save tensorboard logs every X iterations.')
parser.add_argument('--ckp_freq', type=int, default=5000, help='Save checkpoint every X iterations.')
opt = parser.parse_args()
if opt.logging_root is None:
opt.logging_root = os.path.join(opt.data_root, 'logs', 'rnr')
if opt.calib_fp[:2] == '_/':
opt.calib_fp = os.path.join(opt.data_root, opt.calib_fp[2:])
if opt.obj_high_fp[:2] == '_/':
opt.obj_high_fp = os.path.join(opt.data_root, opt.obj_high_fp[2:])
if opt.obj_low_fp[:2] == '_/':
opt.obj_low_fp = os.path.join(opt.data_root, opt.obj_low_fp[2:])
if opt.obj_gcn_fp[:2] == '_/':
opt.obj_gcn_fp = os.path.join(opt.data_root, opt.obj_gcn_fp[2:])
if opt.tex_fp[:2] == '_/':
opt.tex_fp = os.path.join(opt.data_root, opt.tex_fp[2:])
if opt.lp_dir is not None and opt.lp_dir[:2] == '_/':
opt.lp_dir = os.path.join(opt.data_root, opt.lp_dir[2:])
if opt.sphere_samples_fp[:2] == '_/':
opt.sphere_samples_fp = os.path.join(opt.data_root, opt.sphere_samples_fp[2:])
obj_high_name = opt.obj_high_fp.split('/')[-1].split('.')[0]
obj_low_name = opt.obj_low_fp.split('/')[-1].split('.')[0]
opt.precomp_high_dir = os.path.join(opt.data_root, 'precomp_' + obj_high_name)
opt.precomp_low_dir = os.path.join(opt.data_root, 'precomp_' + obj_low_name)
print('\n'.join(["%s: %s" % (key, value) for key, value in vars(opt).items()]))
# device allocation
if opt.gpu_id == '':
device_gcn = torch.device('cpu')
device = torch.device('cpu')
else:
os.environ["CUDA_VISIBLE_DEVICES"] = opt.gpu_id
device_gcn = torch.device('cuda:' + opt.gpu_id[0])
device = torch.device('cuda:' + opt.gpu_id[-1])
# load global_RT
if opt.calib_format == 'convert':
global_RT = torch.from_numpy(scipy.io.loadmat(opt.calib_fp)['global_RT'].astype(np.float32))
else:
global_RT = None
# load texture of obj
texture_init = cv2.cvtColor(cv2.imread(opt.tex_fp), cv2.COLOR_BGR2RGB)
texture_init_resize = cv2.resize(texture_init, (opt.texture_size, opt.texture_size), interpolation = cv2.INTER_AREA).astype(np.float32) / 255.0
texture_init_use = None
if opt.init_tex is True:
texture_init_use = torch.from_numpy(texture_init_resize)
num_channel = texture_init.shape[-1]
# sample light directions on sphere
l_dir_np = scipy.io.loadmat(opt.sphere_samples_fp)['sphere_samples'].transpose() # [3, num_sample]
l_dir = torch.from_numpy(l_dir_np) # [3, num_sample]
num_sample = l_dir.shape[1]
# handle lighting options
has_lighting_gt = True
if opt.lighting_idx is None:
has_lighting_gt = False
opt.lighting_idx = 0 # store estimated lighting as the first lighting
has_lighting_init = opt.init_lighting
has_lighting_relight = True
if opt.lighting_relight_idx is None:
has_lighting_relight = False
# dataset for training views
if opt.lighting_idx is not None:
img_dir = opt.data_root + '/rgb' + str(opt.lighting_idx) + '/'
else:
img_dir = opt.data_root + '/rgb0/'
view_dataset = dataio.ViewDataset(root_dir = opt.data_root,
img_dir = img_dir,
calib_path = opt.calib_fp,
calib_format = opt.calib_format,
img_size = [opt.img_size, opt.img_size],
sampling_pattern = opt.sampling_pattern,
load_precompute = True,
precomp_high_dir = opt.precomp_high_dir,
precomp_low_dir = opt.precomp_low_dir,
img_gamma = opt.img_gamma,
)
# dataset for relighted training views
img_relight_dir = opt.data_root + '/rgb' + str(opt.lighting_relight_idx) + '/'
if os.path.isdir(img_relight_dir):
view_dataset_relight = dataio.ViewDataset(root_dir = opt.data_root,
img_dir = img_relight_dir,
calib_path = opt.calib_fp,
calib_format = opt.calib_format,
img_size = [opt.img_size, opt.img_size],
sampling_pattern = opt.sampling_pattern,
img_gamma = opt.img_gamma,
)
has_view_relight = has_lighting_relight and ('view_dataset_relight' in globals())
# dataset for validation views
view_val_dataset = dataio.ViewDataset(root_dir = opt.data_root,
img_dir = img_dir,
calib_path = opt.calib_fp,
calib_format = opt.calib_format,
img_size = [opt.img_size, opt.img_size],
sampling_pattern = opt.sampling_pattern_val,
load_precompute = True,
precomp_high_dir = opt.precomp_high_dir,
precomp_low_dir = opt.precomp_low_dir,
img_gamma = opt.img_gamma,
)
num_view_val = len(view_val_dataset)
# dataset for relighted validation views
if os.path.isdir(img_relight_dir):
view_val_dataset_relight = dataio.ViewDataset(root_dir = opt.data_root,
img_dir = img_relight_dir,
calib_path = opt.calib_fp,
calib_format = opt.calib_format,
img_size = [opt.img_size, opt.img_size],
sampling_pattern = opt.sampling_pattern_val,
img_gamma = opt.img_gamma,
)
# dataset loader for light probes
if opt.lp_dir is not None:
lp_dataset = dataio.LightProbeDataset(data_dir = opt.lp_dir)
print('Start buffering light probe data...')
lp_dataset.buffer_all()
lp_dataloader = DataLoader(lp_dataset, batch_size = 1, shuffle = False, num_workers = 8)
else:
lp_dataloader = None
# interpolater
interpolater = network.Interpolater()
# texture mapper
texture_mapper = network.TextureMapper(texture_size = opt.texture_size,
texture_num_ch = opt.texture_num_ch,
mipmap_level = opt.mipmap_level,
texture_init = texture_init_use,
fix_texture = opt.fix_tex,
apply_sh = opt.apply_sh)
# gcn input
v_attr, f_attr = nr.load_obj(opt.obj_gcn_fp, normalization = False, use_cuda = False)
gcn_input = torch_geometric.data.Data(pos = v_attr['v'], x = v_attr['v']).to(device_gcn)
opt.num_v_gcn = v_attr['v'].shape[0]
# deep_gcn
gcn = network.DenseDeepGCN(opt)
# lighting model lp
if lp_dataloader is not None:
lighting_model_lp = network.LightingLP(l_dir, num_channel = num_channel, lp_dataloader = lp_dataloader, fix_params = opt.fix_lighting)
lighting_model_lp.fit_sh(lmax = opt.sh_lmax)
# lighting model sh
if 'lighting_model_lp' in globals():
lighting_model_sh = network.LightingSH(l_dir, lmax = opt.sh_lmax, num_lighting = lighting_model_lp.num_lighting, num_channel = num_channel, init_coeff = lighting_model_lp.sh_coeff, fix_params = opt.fix_lighting, lp_recon_h = 256, lp_recon_w = 512)
else:
lighting_model_sh = network.LightingSH(l_dir, lmax = opt.sh_lmax, num_lighting = 1, num_channel = num_channel, fix_params = opt.fix_lighting, lp_recon_h = 256, lp_recon_w = 512)
lighting_model = lighting_model_sh
#################### process lighting ####################
# load stitched light probes
if opt.lighting_idx is None:
idx_use = 0
else:
idx_use = opt.lighting_idx
lp_stitch_dir = os.path.join(opt.data_root, 'light_probe_stitch_' + opt.sampling_pattern)
if os.path.isfile(os.path.join(lp_stitch_dir, str(idx_use) + '.exr')):
lp_stitch = cv2.imread(os.path.join(lp_stitch_dir, str(idx_use) + '.exr'), cv2.IMREAD_ANYCOLOR | cv2.IMREAD_ANYDEPTH)
else:
lp_stitch = cv2.imread(os.path.join(lp_stitch_dir, str(idx_use) + '.png'), cv2.IMREAD_UNCHANGED)[:, :, :3].astype(np.float32) / 255.
lp_stitch[np.isnan(lp_stitch)] = 0
lp_stitch = cv2.cvtColor(lp_stitch, cv2.COLOR_BGR2RGB) ** opt.img_gamma
lp_stitch_mask = cv2.imread(os.path.join(lp_stitch_dir, 'mask', str(idx_use) + '.png')).astype(np.float32) / 255.0
lp_stitch_count = scipy.io.loadmat(os.path.join(lp_stitch_dir, 'count', str(idx_use) + '.mat'))
lp_stitch_count = lp_stitch_count['count'].astype(np.float32) / lp_stitch_count['num_view'].astype(np.float32)
# fill in missing regions
for ith_ch in range(num_channel):
lp_stitch[lp_stitch_mask[:, :, ith_ch] == 0, ith_ch] = lp_stitch[lp_stitch_mask[:, :, ith_ch] == 1, ith_ch].mean()
# resize
lp_stitch_resize = cv2.resize(lp_stitch, (lighting_model_sh.lp_recon_w, lighting_model_sh.lp_recon_h), interpolation = cv2.INTER_AREA)
lp_stitch_mask_resize = cv2.resize(lp_stitch_mask, (lighting_model_sh.lp_recon_w, lighting_model_sh.lp_recon_h), interpolation = cv2.INTER_AREA)
lp_stitch_count_resize = cv2.resize(lp_stitch_count, (lighting_model_sh.lp_recon_w, lighting_model_sh.lp_recon_h), interpolation = cv2.INTER_AREA)
# convert to pytorch tensors
lp_stitch = torch.from_numpy(lp_stitch)
lp_stitch_mask = torch.from_numpy(lp_stitch_mask) == 1
lp_stitch_count = torch.from_numpy(lp_stitch_count)
lp_stitch_resize = torch.from_numpy(lp_stitch_resize).to(device)
lp_stitch_mask_resize = (torch.from_numpy(lp_stitch_mask_resize) == 1).to(device)
lp_stitch_count_resize = torch.from_numpy(lp_stitch_count_resize).to(device)
# fit sh to lp_stitch
l_samples_uv = render.spherical_mapping(l_dir) # [2, num_sample]
l_samples_lp_stitch = misc.interpolate_bilinear(lp_stitch, (l_samples_uv[None, 0, :] * float(lp_stitch.shape[1])).clamp(max = lp_stitch.shape[1] - 1), (l_samples_uv[None, 1, :] * float(lp_stitch.shape[0])).clamp(max = lp_stitch.shape[0] - 1))[0, :] # [num_sample, num_channel]
l_samples_mask = misc.interpolate_bilinear(lp_stitch_mask.to(torch.float32), (l_samples_uv[None, 0, :] * float(lp_stitch.shape[1])).clamp(max = lp_stitch.shape[1] - 1), (l_samples_uv[None, 1, :] * float(lp_stitch.shape[0])).clamp(max = lp_stitch.shape[0] - 1))[0, :, 0] == 1 # [num_sample]
lp_stitch_sh_coeff = sph_harm.fit_sh_coeff(samples = l_samples_lp_stitch, sh_basis_val = lighting_model_sh.basis_val) # [num_basis, num_channel]
# lighting gt (sh and reconstructed lp)
if has_lighting_gt:
lighting_sh_coeff_gt = lighting_model_sh.coeff.data[opt.lighting_idx, :].clone().to(device) # [num_basis, num_channel]
lp_gt = lighting_model_sh.reconstruct_lp(lighting_sh_coeff_gt.cpu()).to(device)
# lighting stitch (sh and reconstructed lp)
lighting_sh_coeff_stitch = lp_stitch_sh_coeff.to(device)
lp_stitch_sh_recon = lighting_model_sh.reconstruct_lp(lighting_sh_coeff_stitch.cpu()).to(device) # [H, W, C]
# initialize lighting
if has_lighting_init:
lighting_sh_coeff_init = lighting_sh_coeff_stitch.clone() # [num_basis, num_channel]
lighting_model_sh.coeff.data[opt.lighting_idx, :] = lighting_sh_coeff_init # initialize
lp_init = lighting_model_sh.reconstruct_lp(lighting_sh_coeff_init.cpu()).to(device)
l_samples_init = l_samples_lp_stitch.clone().to(device)
l_samples_init_mask = l_samples_mask.clone().to(device)
else:
lighting_model_sh.coeff.data[opt.lighting_idx, :] = 0.1 # reset lighting params, don't set to zero (normalize_factor will be nan)
# get lighting data for relight
if has_lighting_relight:
l_samples_relight_lp = lighting_model_lp.l_samples.data[opt.lighting_relight_idx, :].to(device) # [num_sample, num_channel]
lp_relight_lp = lighting_model_lp.lps[opt.lighting_relight_idx, :].to(device) # [H, W, C]
l_samples_relight_sh = lighting_model_sh.l_samples.data[opt.lighting_relight_idx, :].to(device) # [num_sample, num_channel]
lp_relight_sh = lighting_model_sh.reconstruct_lp(lighting_model_sh.coeff.data[opt.lighting_relight_idx, :]).to(device) # [H, W, C]
l_samples_relight = l_samples_relight_sh
lp_relight = lp_relight_sh
########################################
# ray sampler specular
opt.num_azi = 6
opt.num_polar = 2
opt.interval_polar = 5
ray_sampler = network.RaySampler(num_azi = opt.num_azi, num_polar = opt.num_polar, interval_polar = opt.interval_polar)
num_ray = ray_sampler.num_ray
# ray sampler diffuse
opt.num_azi = 6
opt.num_polar = 2
opt.interval_polar = 10
ray_sampler_diffuse = network.RaySampler(num_azi = opt.num_azi, num_polar = opt.num_polar, interval_polar = opt.interval_polar, mode = 'diffuse')
num_ray_diffuse = ray_sampler_diffuse.num_ray
num_ray_total = num_ray + num_ray_diffuse
# rendering net
render_net = network.RenderingNet(nf0 = opt.nf0,
in_channels = num_ray_total * 3 + 6 + opt.texture_num_ch,
out_channels = 3 * num_ray_total,
num_down_unet = 5,
out_channels_gcn = opt.out_channels_gcn)
# ray renderer
ray_renderer = network.RayRenderer(lighting_model, interpolater)
# L1 loss
criterionL1 = nn.L1Loss(reduction = 'mean').to(device)
# Chrom loss
criterion_rays_lt_chrom = network.RaysLTChromLoss().to(device)
# Optimizer
optimizerG = torch.optim.Adam(list(gcn.parameters()) + list(texture_mapper.parameters()) + list(lighting_model.parameters()) + list(render_net.parameters()), lr = opt.lr)
optimizerG.zero_grad()
# move to device
interpolater.to(device)
texture_mapper.to(device)
lighting_model.to(device)
ray_sampler.to(device)
ray_sampler_diffuse.to(device)
render_net.to(device)
ray_renderer.to(device)
gcn.to(device_gcn)
# get module
texture_mapper_module = texture_mapper
lighting_model_module = lighting_model
ray_sampler_module = ray_sampler
ray_sampler_diffuse_module = ray_sampler_diffuse
render_net_module = render_net
gcn_module = gcn
# set to training mode
interpolater.train()
texture_mapper.train()
lighting_model.train()
ray_sampler.train()
ray_sampler_diffuse.train()
render_net.train()
ray_renderer.train()
gcn.train()
# collect all networks and optimizers
part_list = [texture_mapper_module, lighting_model_module, ray_sampler_module, ray_sampler_diffuse_module, render_net_module, gcn_module, []]
part_name_list = ['texture_mapper', 'lighting_model', 'ray_sampler', 'ray_sampler_diffuse', 'render_net', 'gcn', 'v_feature']
print("*" * 100)
print("Number of parameters")
print("texture mapper:")
opt.num_params_texture_mapper = util.print_network(texture_mapper)
print("lighting model:")
opt.num_params_lighting_model = util.print_network(lighting_model)
print("render net:")
opt.num_params_render_net = util.print_network(render_net)
print("gcn:")
opt.num_params_gcn = util.print_network(gcn)
print("*" * 100)
def main():
print('Start buffering data for training views...')
view_dataset.buffer_all()
view_dataloader = DataLoader(view_dataset, batch_size = opt.batch_size, shuffle = True, num_workers = 8)
if has_view_relight:
print('Start buffering data for relighted training views...')
view_dataset_relight.buffer_all()
print('Start buffering data for validation views...')
view_val_dataset.buffer_all()
view_val_dataloader = DataLoader(view_val_dataset, batch_size = opt.batch_size, shuffle = False, num_workers = 8)
if has_view_relight:
print('Start buffering data for relighted validation views...')
view_val_dataset_relight.buffer_all()
# directory name contains some info about hyperparameters.
dir_name = os.path.join(datetime.datetime.now().strftime('%m-%d') +
'_' + datetime.datetime.now().strftime('%H-%M-%S') +
'_' + opt.sampling_pattern +
'_' + opt.data_root.strip('/').split('/')[-1])
if opt.exp_name is not '':
dir_name += '_' + opt.exp_name
# directory for logging
log_dir = os.path.join(opt.logging_root, dir_name)
data_util.cond_mkdir(log_dir)
# directory for saving validation data on view synthesis
val_out_dir = os.path.join(log_dir, 'val_out')
val_gt_dir = os.path.join(log_dir, 'val_gt')
val_err_dir = os.path.join(log_dir, 'val_err')
data_util.cond_mkdir(val_out_dir)
data_util.cond_mkdir(val_gt_dir)
data_util.cond_mkdir(val_err_dir)
# directory for saving validation data on relighting
val_relight_out_dir = os.path.join(log_dir, 'val_relight_out')
data_util.cond_mkdir(val_relight_out_dir)
if has_view_relight:
val_relight_gt_dir = os.path.join(log_dir, 'val_relight_gt')
val_relight_err_dir = os.path.join(log_dir, 'val_relight_err')
data_util.cond_mkdir(val_relight_gt_dir)
data_util.cond_mkdir(val_relight_err_dir)
# Save all command line arguments into a txt file in the logging directory for later reference.
with open(os.path.join(log_dir, "params.txt"), "w") as out_file:
out_file.write('\n'.join(["%s: %s" % (key, value) for key, value in vars(opt).items()]))
# tensorboardX writer
writer = SummaryWriter(log_dir)
iter = opt.start_epoch * len(view_dataset)
print('Begin training...')
val_log_batch_id = 0
first_val = True
for epoch in range(opt.start_epoch, opt.max_epoch):
for view_trgt in view_dataloader:
if opt.max_iter is not None and iter >= opt.max_iter:
return
start = time.time()
# gcn features
v_feature = gcn(gcn_input).to(device)
# get view data
TBN_map = view_trgt[0]['TBN_map'].to(device) # [N, H, W, 3, 3]
uv_map = view_trgt[0]['uv_map'].to(device) # [N, H, W, 2]
sh_basis_map = view_trgt[0]['sh_basis_map'].to(device) # [N, H, W, 9]
normal_map = view_trgt[0]['normal_map'].to(device) # [N, H, W, 3]
view_dir_map = view_trgt[0]['view_dir_map'].to(device) # [N, H, W, 3]
view_dir_map_tangent = view_trgt[0]['view_dir_map_tangent'].to(device) # [N, H, W, 3]
alpha_map = view_trgt[0]['alpha_map'][:, None, :, :].to(device) # [N, 1, H, W]
view_idx = view_trgt[0]['idx']
batch_size = alpha_map.shape[0]
img_h = alpha_map.shape[2]
img_w = alpha_map.shape[3]
num_view = len(view_trgt)
img_gt = []
for i in range(num_view):
img_gt.append(view_trgt[i]['img_gt'].to(device)) # [N, C, H, W]
# sample texture
neural_img = texture_mapper(uv_map, sh_basis_map, sh_start_ch = 6) # [N, C, H, W]
albedo_diffuse = neural_img[:, :3, :, :]
albedo_specular = neural_img[:, 3:6, :, :]
# sample specular rays
rays_dir, rays_uv, rays_dir_tangent = ray_sampler(TBN_map, view_dir_map_tangent, alpha_map.permute((0, 2, 3, 1))) # [N, H, W, 3, num_ray], [N, H, W, 2, num_ray], [N, H, W, 3, num_ray]
num_ray = rays_uv.shape[-1]
# sample diffuse rays
rays_diffuse_dir, rays_diffuse_uv, _ = ray_sampler_diffuse(TBN_map, view_dir_map_tangent, alpha_map.permute((0, 2, 3, 1))) # [N, H, W, 3, num_ray], [N, H, W, 2, num_ray]
num_ray_diffuse = rays_diffuse_uv.shape[-1]
num_ray_total = num_ray + num_ray_diffuse
# concat data
rays_dir = torch.cat((rays_dir, rays_diffuse_dir), dim = -1)
rays_uv = torch.cat((rays_uv, rays_diffuse_uv), dim = -1)
# estimate light transport for rays
render_net_input = torch.cat((rays_dir.permute((0, -1, -2, 1, 2)).reshape((batch_size, -1, img_h, img_w)),
normal_map.permute((0, 3, 1, 2)),
view_dir_map.permute((0, 3, 1, 2)),
neural_img), dim = 1)
rays_lt = render_net(render_net_input, v_feature).reshape((batch_size, num_ray_total, -1, img_h, img_w)) # [N, num_ray, C, H, W]
lt_max_val = 2.0
rays_lt = (rays_lt * 0.5 + 0.5) * lt_max_val # map to [0, lt_max_val]
# render using ray_renderer
outputs_final, _, _, _, _, _, _ = ray_renderer(albedo_specular, rays_uv, rays_lt, lighting_idx = opt.lighting_idx, albedo_diffuse = albedo_diffuse, num_ray_diffuse = num_ray_diffuse, seperate_albedo = True)
outputs_final = [outputs_final] # [N, C, H, W]
with torch.no_grad():
# relight
if has_lighting_relight:
# ray renderer
outputs_final_relight, _, _, _, _, _, _ = ray_renderer(albedo_specular, rays_uv, rays_lt, lp = lp_relight[None, :].expand(batch_size, -1, -1, -1), albedo_diffuse = albedo_diffuse, num_ray_diffuse = num_ray_diffuse, seperate_albedo = True)
outputs_final_relight = [outputs_final_relight] # [N, C, H, W]
# relight gt
if has_view_relight:
img_relight_gt = []
for i in range(batch_size):
img_relight_gt.append(view_dataset_relight.views_all[view_idx[i]]['img_gt'])
img_relight_gt = torch.stack(img_relight_gt).to(device)
img_relight_gt = [img_relight_gt]
# get estimated lighting SH coeffs
lighting_sh_coeff_est = lighting_model_module.get_lighting_params(opt.lighting_idx) # [num_basis, num_channel]
# reconstruct light probe
lp_est = lighting_model_module.reconstruct_lp(lighting_sh_coeff_est)
# reconstruct light samples
l_samples_est = sph_harm.reconstruct_sh(lighting_sh_coeff_est, lighting_model_module.basis_val)
# We don't enforce a loss on the outermost 5 pixels to alleviate boundary errors, also weight loss by alpha
alpha_map_central = alpha_map[:, :, 5:-5, 5:-5]
img_gt_orig = img_gt[0].clone()
for i in range(num_view):
outputs_final[i] = outputs_final[i][:, :, 5:-5, 5:-5] * alpha_map_central
img_gt[i] = img_gt[i][:, :, 5:-5, 5:-5] * alpha_map_central
if has_lighting_relight:
outputs_final_relight[i] = outputs_final_relight[i][:, :, 5:-5, 5:-5] * alpha_map_central
if has_view_relight:
img_relight_gt[i] = img_relight_gt[i][:, :, 5:-5, 5:-5] * alpha_map_central
loss_lighting = 0
if not opt.fix_lighting:
# loss on estimated light samples
loss_lighting = (l_samples_init[l_samples_init_mask, :] - l_samples_est[l_samples_init_mask, :]).abs().sum() / l_samples_init_mask.to(l_samples_est.dtype).sum() * opt.loss_lighting_weight
loss_lighting = loss_lighting + (l_samples_init[(l_samples_init_mask != 1), :] - l_samples_est[(l_samples_init_mask != 1), :]).abs().sum() / (l_samples_init_mask != 1).to(l_samples_est.dtype).sum() * opt.loss_lighting_uncovered_weight
# loss on final img
loss_rn = list()
for idx in range(num_view):
loss_rn.append(criterionL1(outputs_final[idx].contiguous().view(-1).float(), img_gt[idx].view(-1).float()))
loss_rn = torch.stack(loss_rn, dim = 0).mean()
# loss on rays light transport chromaticity
try:
loss_rays_lt_chrom, rays_lt_chrom, rays_lt_chrom_mean, rays_lt_chrom_diff = criterion_rays_lt_chrom(rays_lt, alpha_map, img_gt_orig)
except:
loss_rays_lt_chrom, rays_lt_chrom, rays_lt_chrom_mean, rays_lt_chrom_diff = criterion_rays_lt_chrom.cpu()(rays_lt.cpu(), alpha_map.cpu(), img_gt_orig.cpu())
loss_rays_lt_chrom = loss_rays_lt_chrom.to(device)
loss_rays_lt_chrom = loss_rays_lt_chrom * opt.loss_rays_lt_chrom_weight
# loss on albedo mean value
albedo_specular_tex = texture_mapper_module.flatten_mipmap(start_ch = 3, end_ch = 6) # [1, H, W, C]
albedo_diffuse_tex = texture_mapper_module.flatten_mipmap(start_ch = 0, end_ch = 3) # [1, H, W, C]
mask_valid_tex_spec = (albedo_specular_tex != texture_mapper_module.tex_flatten_mipmap_init[..., 3:6]).any(dim = -1, keepdim = True).to(albedo_specular_tex.dtype)
if mask_valid_tex_spec.sum(dim = (0, 1, 2)) == 0:
loss_alb_spec = torch.zeros(1).to(device)
else:
loss_alb_spec = ((albedo_specular_tex * mask_valid_tex_spec).sum(dim = (0, 1, 2)) / mask_valid_tex_spec.sum(dim = (0, 1, 2)) - 0.5).abs().sum() / num_channel
mask_valid_tex_diff = (albedo_diffuse_tex != texture_mapper_module.tex_flatten_mipmap_init[..., 0:3]).any(dim = -1, keepdim = True).to(albedo_diffuse_tex.dtype)
if mask_valid_tex_diff.sum(dim = (0, 1, 2)) == 0:
loss_alb_diff = torch.zeros(1).to(device)
else:
loss_alb_diff = ((albedo_diffuse_tex * mask_valid_tex_diff).sum(dim = (0, 1, 2)) / mask_valid_tex_diff.sum(dim = (0, 1, 2)) - 0.5).abs().sum() / num_channel
loss_alb = (loss_alb_spec + loss_alb_diff) * opt.loss_alb_weight
# total loss
loss_g = loss_lighting + loss_rn + loss_rays_lt_chrom + loss_alb
# compute gradients
optimizer_step = True
if not optimizer_step:
loss_g.backward(retain_graph = True)
else:
loss_g.backward(retain_graph = False)
# optimize
if optimizer_step:
optimizerG.step()
optimizerG.zero_grad()
# error metrics
with torch.no_grad():
err_metrics_batch_i_final = metric.compute_err_metrics_batch(outputs_final[0] * 255.0, img_gt[0] * 255.0, alpha_map_central, compute_ssim = False)
if has_view_relight:
err_metrics_batch_i_final_relight = metric.compute_err_metrics_batch(outputs_final_relight[0] * 255.0, img_relight_gt[0] * 255.0, alpha_map_central, compute_ssim = False)
if has_lighting_gt:
lighting_sh_coeff_mae = (lighting_sh_coeff_gt.to(lighting_sh_coeff_est.dtype) - lighting_sh_coeff_est).abs().sum()
err_metrics_batch_i_lp = metric.compute_err_metrics_batch(lp_est.permute((2, 0, 1))[None, :] * 255.0, lp_gt.to(lp_est.dtype).permute((2, 0, 1))[None, :] * 255.0, torch.ones_like(lp_est).permute((2, 0, 1))[None, :], compute_ssim = False)
# tensorboard scalar logs of training data
if optimizer_step:
writer.add_scalar("loss_g", loss_g, iter)
writer.add_scalar("loss_lighting", loss_lighting, iter)
writer.add_scalar("loss_rn", loss_rn, iter)
writer.add_scalar("loss_rays_lt_chrom", loss_rays_lt_chrom, iter)
writer.add_scalar("loss_alb", loss_alb, iter)
writer.add_scalar("final_mae_valid", err_metrics_batch_i_final['mae_valid_mean'], iter)
writer.add_scalar("final_psnr_valid", err_metrics_batch_i_final['psnr_valid_mean'], iter)
if has_view_relight:
writer.add_scalar("final_relight_mae_valid", err_metrics_batch_i_final_relight['mae_valid_mean'], iter)
writer.add_scalar("final_relight_psnr_valid", err_metrics_batch_i_final_relight['psnr_valid_mean'], iter)
if has_lighting_gt:
writer.add_scalar("lighting_sh_coeff_mae", lighting_sh_coeff_mae, iter)
writer.add_scalar("lp_mae_valid", err_metrics_batch_i_lp['mae_valid_mean'], iter)
writer.add_scalar("lp_psnr_valid", err_metrics_batch_i_lp['psnr_valid_mean'], iter)
end = time.time()
print("Iter %07d Epoch %03d loss_g %0.4f mae_valid %0.4f psnr_valid %0.4f t_total %0.4f" % (iter, epoch, loss_g, err_metrics_batch_i_final['mae_valid_mean'], err_metrics_batch_i_final['psnr_valid_mean'], end - start))
# tensorboard figure logs of training data
if not iter % opt.log_freq:
output_final_vs_gt = []
for i in range(num_view):
output_final_vs_gt.append(outputs_final[i].clamp(min = 0., max = 1.))
output_final_vs_gt.append(img_gt[i].clamp(min = 0., max = 1.))
output_final_vs_gt.append((outputs_final[i] - img_gt[i]).abs().clamp(min = 0., max = 1.))
output_final_vs_gt = torch.cat(output_final_vs_gt, dim = 0)
writer.add_image("output_final_vs_gt",
torchvision.utils.make_grid(output_final_vs_gt,
nrow = batch_size,
range = (0, 1),
scale_each = False,
normalize = False).cpu().detach().numpy(),
iter)
lp_init_est_gt = []
if has_lighting_init:
lp_init_est_gt.append(lp_init.to(lp_est.dtype).permute((2, 0, 1))[None, :].clamp(min = 0., max = 1.))
lp_init_est_gt.append(lp_est.permute((2, 0, 1))[None, :].clamp(min = 0., max = 1.))
if has_lighting_gt:
lp_init_est_gt.append(lp_gt.to(lp_est.dtype).permute((2, 0, 1))[None, :].clamp(min = 0., max = 1.))
lp_init_est_gt.append((lp_est - lp_gt.to(lp_est.dtype)).abs().permute((2, 0, 1))[None, :].clamp(min = 0., max = 1.))
lp_init_est_gt = torch.cat(lp_init_est_gt, dim = 0)
writer.add_image("lp_init_est_gt",
torchvision.utils.make_grid(lp_init_est_gt,
nrow = 1,
range = (0, 1),
scale_each = False,
normalize = False).cpu().detach().numpy(),
iter)
if has_lighting_relight:
relight_final_est_gt = []
for i in range(num_view):
relight_final_est_gt.append(outputs_final_relight[i].clamp(min = 0., max = 1.))
if has_view_relight:
relight_final_est_gt.append(img_relight_gt[i].clamp(min = 0., max = 1.))
relight_final_est_gt.append((outputs_final_relight[i] - img_relight_gt[i]).abs().clamp(min = 0., max = 1.))
relight_final_est_gt = torch.cat(relight_final_est_gt, dim = 0)
writer.add_image("relight_final_est_gt",
torchvision.utils.make_grid(relight_final_est_gt,
nrow = batch_size,
range = (0, 1),
scale_each = False,
normalize = False).cpu().detach().numpy(),
iter)
# validation
if not iter % opt.val_freq:
start_val = time.time()
with torch.no_grad():
# error metrics
err_metrics_val = {}
err_metrics_val['mae_valid'] = []
err_metrics_val['mse_valid'] = []
err_metrics_val['psnr_valid'] = []
err_metrics_val['ssim_valid'] = []
err_metrics_val_relight = {}
err_metrics_val_relight['mae_valid'] = []
err_metrics_val_relight['mse_valid'] = []
err_metrics_val_relight['psnr_valid'] = []
err_metrics_val_relight['ssim_valid'] = []
# gcn features
v_feature = gcn(gcn_input).to(device)
# loop over batches
batch_id = 0
for view_val_trgt in view_val_dataloader:
start_val_i = time.time()
# get view data
TBN_map = view_val_trgt[0]['TBN_map'].to(device) # [N, H, W, 3, 3]
uv_map = view_val_trgt[0]['uv_map'].to(device) # [N, H, W, 2]
sh_basis_map = view_val_trgt[0]['sh_basis_map'].to(device) # [N, H, W, 9]
normal_map = view_val_trgt[0]['normal_map'].to(device) # [N, H, W, 3]
view_dir_map = view_val_trgt[0]['view_dir_map'].to(device) # [N, H, W, 3]
view_dir_map_tangent = view_val_trgt[0]['view_dir_map_tangent'].to(device) # [N, H, W, 3]
alpha_map = view_val_trgt[0]['alpha_map'][:, None, :, :].to(device) # [N, 1, H, W]
view_idx = view_val_trgt[0]['idx']
batch_size = alpha_map.shape[0]
img_h = alpha_map.shape[2]
img_w = alpha_map.shape[3]
num_view = len(view_val_trgt)
img_gt = []
for i in range(num_view):
img_gt.append(view_val_trgt[i]['img_gt'].to(device)) # [N, C, H, W]
# sample texture
neural_img = texture_mapper(uv_map, sh_basis_map, sh_start_ch = 6) # [N, C, H, W]
albedo_diffuse = neural_img[:, :3, :, :]
albedo_specular = neural_img[:, 3:6, :, :]
# sample specular rays
rays_dir, rays_uv, rays_dir_tangent = ray_sampler(TBN_map, view_dir_map_tangent, alpha_map.permute((0, 2, 3, 1))) # [N, H, W, 3, num_ray], [N, H, W, 2, num_ray], [N, H, W, 3, num_ray]
num_ray = rays_uv.shape[-1]
# sample diffuse rays
rays_diffuse_dir, rays_diffuse_uv, _ = ray_sampler_diffuse(TBN_map, view_dir_map_tangent, alpha_map.permute((0, 2, 3, 1))) # [N, H, W, 3, num_ray], [N, H, W, 2, num_ray]
num_ray_diffuse = rays_diffuse_uv.shape[-1]
num_ray_total = num_ray + num_ray_diffuse
# concat data
rays_dir = torch.cat((rays_dir, rays_diffuse_dir), dim = -1)
rays_uv = torch.cat((rays_uv, rays_diffuse_uv), dim = -1)
# estimate light transport for rays
render_net_input = torch.cat((rays_dir.permute((0, -1, -2, 1, 2)).reshape((batch_size, -1, img_h, img_w)),
normal_map.permute((0, 3, 1, 2)),
view_dir_map.permute((0, 3, 1, 2)),
neural_img), dim = 1)
rays_lt = render_net(render_net_input, v_feature).reshape((batch_size, num_ray_total, -1, img_h, img_w)) # [N, num_ray, C, H, W]
rays_lt = (rays_lt * 0.5 + 0.5) * lt_max_val # map to [0, lt_max_val]
outputs_final, _, _, _, _, _, _ = ray_renderer(albedo_specular, rays_uv, rays_lt, lighting_idx = opt.lighting_idx, albedo_diffuse = albedo_diffuse, num_ray_diffuse = num_ray_diffuse, seperate_albedo = True)
outputs_final = [outputs_final] # [N, C, H, W]
# relight
if has_lighting_relight:
# ray renderer
outputs_final_relight, _, _, _, _, _, _ = ray_renderer(albedo_specular, rays_uv, rays_lt, lp = lp_relight[None, :].expand(batch_size, -1, -1, -1), albedo_diffuse = albedo_diffuse, num_ray_diffuse = num_ray_diffuse, seperate_albedo = True)
outputs_final_relight = [outputs_final_relight] # [N, C, H, W]
# relight gt
if has_view_relight:
img_relight_gt = []
for i in range(batch_size):
img_relight_gt.append(view_val_dataset_relight.views_all[view_idx[i]]['img_gt'])
img_relight_gt = torch.stack(img_relight_gt).to(device)
img_relight_gt = [img_relight_gt]
# apply alpha
for i in range(num_view):
outputs_final[i] = outputs_final[i] * alpha_map
img_gt[i] = img_gt[i] * alpha_map
if has_lighting_relight:
outputs_final_relight[i] = outputs_final_relight[i] * alpha_map
if has_view_relight:
img_relight_gt[i] = img_relight_gt[i] * alpha_map
# tensorboard figure logs of validation data
if batch_id == val_log_batch_id:
output_final_vs_gt = []
for i in range(num_view):
output_final_vs_gt.append(outputs_final[i].clamp(min = 0., max = 1.))
output_final_vs_gt.append(img_gt[i].clamp(min = 0., max = 1.))
output_final_vs_gt.append((outputs_final[i] - img_gt[i]).abs().clamp(min = 0., max = 1.))
output_final_vs_gt = torch.cat(output_final_vs_gt, dim = 0)
writer.add_image("output_final_vs_gt_val",
torchvision.utils.make_grid(output_final_vs_gt,
nrow = batch_size,
range = (0, 1),
scale_each = False,
normalize = False).cpu().detach().numpy(),
iter)
if has_lighting_relight:
relight_final_est_gt = []
for i in range(num_view):
relight_final_est_gt.append(outputs_final_relight[i].clamp(min = 0., max = 1.))
if has_view_relight:
relight_final_est_gt.append(img_relight_gt[i].clamp(min = 0., max = 1.))
relight_final_est_gt.append((outputs_final_relight[i] - img_relight_gt[i]).abs().clamp(min = 0., max = 1.))
relight_final_est_gt = torch.cat(relight_final_est_gt, dim = 0)
writer.add_image("relight_final_est_gt_val",
torchvision.utils.make_grid(relight_final_est_gt,
nrow = batch_size,
range = (0, 1),
scale_each = False,
normalize = False).cpu().detach().numpy(),
iter)
# error metrics
err_metrics_batch_i_final = metric.compute_err_metrics_batch(outputs_final[0] * 255.0, img_gt[0] * 255.0, alpha_map, compute_ssim = True)
if has_view_relight:
err_metrics_batch_i_final_relight = metric.compute_err_metrics_batch(outputs_final_relight[0] * 255.0, img_relight_gt[0] * 255.0, alpha_map, compute_ssim = True)
for i in range(batch_size):
for key in list(err_metrics_val.keys()):
if key in err_metrics_batch_i_final.keys():
err_metrics_val[key].append(err_metrics_batch_i_final[key][i])
if has_view_relight:
err_metrics_val_relight[key].append(err_metrics_batch_i_final_relight[key][i])
# save images
for i in range(batch_size):
cv2.imwrite(os.path.join(val_out_dir, str(iter).zfill(8) + '_' + str(view_idx[i].cpu().detach().numpy()).zfill(5) + '.png'), outputs_final[0][i, :].permute((1, 2, 0)).cpu().detach().numpy()[:, :, ::-1] * 255.)
cv2.imwrite(os.path.join(val_err_dir, str(iter).zfill(8) + '_' + str(view_idx[i].cpu().detach().numpy()).zfill(5) + '.png'), (outputs_final[0] - img_gt[0]).abs().clamp(min = 0., max = 1.)[i, :].permute((1, 2, 0)).cpu().detach().numpy()[:, :, ::-1] * 255.)
if first_val:
cv2.imwrite(os.path.join(val_gt_dir, str(view_idx[i].cpu().detach().numpy()).zfill(5) + '.png'), img_gt[0][i, :].permute((1, 2, 0)).cpu().detach().numpy()[:, :, ::-1] * 255.)
cv2.imwrite(os.path.join(val_relight_out_dir, str(iter).zfill(8) + '_' + str(view_idx[i].cpu().detach().numpy()).zfill(5) + '.png'), outputs_final_relight[0][i, :].permute((1, 2, 0)).cpu().detach().numpy()[:, :, ::-1] * 255.)
if has_view_relight:
cv2.imwrite(os.path.join(val_relight_err_dir, str(iter).zfill(8) + '_' + str(view_idx[i].cpu().detach().numpy()).zfill(5) + '.png'), (outputs_final_relight[0] - img_relight_gt[0]).abs().clamp(min = 0., max = 1.)[i, :].permute((1, 2, 0)).cpu().detach().numpy()[:, :, ::-1] * 255.)
if first_val:
cv2.imwrite(os.path.join(val_relight_gt_dir, str(view_idx[i].cpu().detach().numpy()).zfill(5) + '.png'), img_relight_gt[0][i, :].permute((1, 2, 0)).cpu().detach().numpy()[:, :, ::-1] * 255.)
end_val_i = time.time()
print("Val batch %03d mae_valid %0.4f psnr_valid %0.4f ssim_valid %0.4f t_total %0.4f" % (batch_id, err_metrics_batch_i_final['mae_valid_mean'], err_metrics_batch_i_final['psnr_valid_mean'], err_metrics_batch_i_final['ssim_valid_mean'], end_val_i - start_val_i))
batch_id += 1
for key in list(err_metrics_val.keys()):
if err_metrics_val[key]:
err_metrics_val[key] = | np.vstack(err_metrics_val[key]) | numpy.vstack |
import numpy as np
a = np.array([[0, 1, 1 / 2, 0, 1 / 4, 1 / 2, 0],
[1 / 5, 0, 1 / 2, 1 / 3, 0, 0, 0],
[1 / 5, 0, 0, 1 / 3, 1 / 4, 0, 0],
[1 / 5, 0, 0, 0, 1 / 4, 0, 0],
[1 / 5, 0, 0, 1 / 3, 0, 1 / 2, 1],
[0, 0, 0, 0, 1 / 4, 0, 0],
[1 / 5, 0, 0, 0, 0, 0, 0]], dtype=float)
pr = np.array([[1 / 2],
[1 / 3],
[1 / 4],
[0],
[0],
[0],
[0]], dtype=float)
# print Pagerank matrix
def show_matrix(matrix, pr):
print()
print('Metrix:')
n = len(pr)
for i in range(n):
for j in range(n):
print(matrix[i][j], ' ', end=' ')
print()
print()
print('Pr:')
for i in range(n):
print(pr[i][0], ' ', end=' ')
print('\nSize:', len(pr))
def normalization(a):
sumCol = np.sum(a, axis=0)
for i in range(a.shape[0]):
if sumCol[i] == 0:
print('col: %d, sum: %.5f' % (i, sumCol[i]))
continue
for j in range(a.shape[1]):
a[j][i] = a[j][i] / sumCol[i]
return a
def firstPr(c):
pr = np.zeros((c.shape[0], 1), dtype=float)
# sum = np.sum(c, axis=0)[0]
# print(sum)
for i in range(c.shape[0]):
pr[i] = c[i][0] / c.shape[0]
# print pr,"\n==================================================="
return pr
'''
Calculate pagerank weight of anormaly_list or normal_list
:arg
:return
operation weight:
weight[operation][0]: operation
weight[operation][1]: weight
'''
def trace_pagerank(operation_operation, operation_trace, trace_operation, pr_trace, anomaly):
operation_length = len(operation_operation)
trace_length = len(operation_trace)
p_ss = np.zeros((operation_length, operation_length), dtype=np.float32)
p_sr = np.zeros((operation_length, trace_length), dtype=np.float32)
p_rs = np.zeros((trace_length, operation_length), dtype=np.float32)
# matrix = np.zeros((n, n), dtype=np.float32)
pr = | np.zeros((trace_length, 1), dtype=np.float32) | numpy.zeros |
import numpy as np
from PIL import Image
import os
from keras.preprocessing import image
from keras.utils import to_categorical
from keras.preprocessing.image import ImageDataGenerator as IDG
from sklearn.preprocessing import LabelBinarizer as LB
def extract_data_from_lst(lst,input_shape,crop_shape=None, preprocess=True, flip=None):
x = []
for file in lst:
im = read_input_img(file,input_shape,crop_shape,flip)
x += [np.asarray(im,dtype='float32')]
x = np.array(x)
if preprocess:
x = img_preprocess(x)
return x
def extract_feature(model,lst):
features = []
for file in lst:
im = read_input_img(file,model.input_shape[1:])
feature = model.predict(np.asarray(im,dtype='float32').reshape((-1,) + model.input_shape[1:]))
features += [np.squeeze(feature)]
return np.array(features)
def crop_image(im,crop_shape):
assert im.width > crop_shape[0] and im.height > crop_shape[1], 'error crop size'
a = np.random.randint(im.width-crop_shape[0]+1)
b = np.random.randint(im.height-crop_shape[1]+1)
c = a + crop_shape[0]
d = b + crop_shape[1]
return im.crop((a,b,c,d))
def random_flip(im,seed=None):
a = np.random.rand()
if a > 0.5:
im = im.transpose(Image.FLIP_LEFT_RIGHT)
return im
def generate_train_lst(dire):
x = []
y = []
cam = []
#files = os.listdir(dire)
files = sorted(os.listdir(dire))
for file in files:
if file.endswith('.jpg'):
x += [dire + file]
if file.startswith('-'):
y += [-1]
cam += [int(file[4])]
else:
y += [int(file[:4])]
cam += [int(file[6])]
return np.array(x),np.array(y),np.array(cam)
def read_input_img(file,shape,crop_shape=None,flip=None):
im = Image.open(file)
if flip is not None:
im = random_flip(im)
im = im.resize((shape[0],shape[1]))
if crop_shape is None:
return im
im = crop_image(im,crop_shape=crop_shape)
return im
def gen_pairs(s,bid,y, kmap, label_set, batch_size, pos_ratio, neg_ratio):
#id_left = np.random.randint(0,len(y),batch_size).tolist()
id_left = s[bid*batch_size:(bid+1)*batch_size]
num_clss = len(label_set)
id_right = []
y_diff,y_cls1,y_cls2 = [],[],[]
threshold = pos_ratio/(pos_ratio + neg_ratio)
for idx in id_left:
v = np.random.rand()
ln = kmap[y[idx]]
y_cls1 += [to_categorical(ln,num_clss).squeeze()]
if v > threshold:
ln = (np.random.randint(1,num_clss) + ln) % num_clss
y_diff += [[0,1]]
else:
y_diff += [[1,0]]
rn = np.random.randint(len(label_set[ln]))
id_right += [label_set[ln][rn]]
y_cls2 += [to_categorical(ln,num_clss).squeeze()]
return id_left, id_right, y_diff
def image_base_generator(data,batch_size,input_shape,crop_shape=None):
lst,y = data['lst'],data['label']
num_ins = len(y)
clss = np.unique(y)
num_clss = clss.shape[0]
num_batchs = num_ins // batch_size
kmap = {v:k for k,v in enumerate(clss)}
s = np.arange(num_ins)
img_cache = {}
while True:
s = np.random.permutation(s)
for batch in range(num_batchs):
indices = s[batch*batch_size:(batch+1)*batch_size]
X = process_images(lst[indices],img_cache,input_shape,crop_shape)
label = np.array([to_categorical(kmap[y[i]],num_clss).squeeze() for i in indices])
yield X,label
def image_quintuple_generator(lst_files,input_shape,batch_size,crop_shape=None):
pos_ratio, neg_ratio = 1,1
pos_limit, neg_limit = 1,4
pos_factor, neg_factor = 1,1.01
img_cache = {}
f = np.load(lst_files)
lst,y = f['lst'],f['label']
num_ins = len(y)
num_batches = num_ins // batch_size + 1
clss = np.unique(y)
num_clss = clss.shape[0]
kmap = { v:k for k,v in enumerate(clss)}
label_set = [np.where(y == c)[0] for c in clss]
s = np.arange(num_ins)
while True:
s=np.random.permutation(s)
#loop per epoch
for bid in range(num_batches):
id_left, id_right, y_diff = gen_pairs(s,bid,y,kmap,label_set, batch_size,pos_ratio, neg_ratio)
Xleft = process_images([lst[i] for i in id_left],img_cache,input_shape,crop_shape)
Xright = process_images([lst[i] for i in id_right],img_cache,input_shape,crop_shape)
Y_diff = np.array(y_diff)
Y_cls1 = np.array([to_categorical(kmap[y[i]],num_clss).squeeze() for i in id_left])
Y_cls2 = np.array([to_categorical(kmap[y[i]],num_clss).squeeze() for i in id_right])
yield [Xleft, Xright], [Y_diff, Y_cls1, Y_cls2]
pos_ratio = min(pos_ratio * pos_factor, pos_limit)
neg_ratio = min(neg_ratio * neg_factor, neg_limit)
def cache_read(img_name, img_cache,input_shape,crop_shape):
if img_name not in img_cache:
img = read_input_img(img_name,input_shape,crop_shape)
img_cache[img_name] = img
return img_cache[img_name]
def process_images(img_names, img_cache,input_shape,crop_shape):
if crop_shape is None:
X = np.zeros((len(img_names), input_shape[0], input_shape[1], 3))
else:
X = np.zeros((len(img_names), crop_shape[0], crop_shape[1], 3))
for idx, img_name in enumerate(img_names):
im = cache_read(img_name, img_cache,input_shape,crop_shape)
X[idx] = np.asarray(im,dtype='float32')
X[:,:,:,2] -= 97.8286
X[:,:,:,1] -= 99.0468
X[:,:,:,0] -= 105.606
return X
def img_preprocess(imgs, shift = (97.8286,99.046,105.606)):
imgs[:,:,:,0] -= shift[2]
imgs[:,:,:,1] -= shift[1]
imgs[:,:,:,2] -= shift[0]
#imgs[:,:,:,0] /= 255
#imgs[:,:,:,1] /= 255
#imgs[:,:,:,2] /= 255
return imgs
def create_pairs(x,y,neg_times=1):
'''Positive and negative pair creation.
Alternates between positive and negative pairs.
'''
neg_size = neg_times
clss = np.unique(y)
num_clss = len(clss)
digit_indices = [np.where(y == c)[0] for c in clss]
pairs = []
label_diff = []
label_clss = []
for d in range(num_clss):
n = len(digit_indices[d])
for i in range(n):
inc = np.random.randint(1,n)
dn = (i + inc) % n
z1, z2 = digit_indices[d][i], digit_indices[d][dn]
l1 = to_categorical(d, num_clss).squeeze()
pairs += [[x[z1], x[z2]]]
label_diff += [[1,0]]
label_clss += [[l1, l1]]
incs = | np.random.randint(1, num_clss, neg_size) | numpy.random.randint |
#!/bin/env python3
import os, sys
# sys.path.append(os.path.join(os.path.dirname(__file__), "lib"))
import numpy as np
from ..measure.intersection import intersection
def testme():
pass
#test cases
test = True
a, b = 1, 2
phi = np.linspace(3, 10, 100)
x1 = a*phi - b*np.sin(phi)
y1 = a - b*np.cos(phi)
x2=phi
y2=np.sin(phi)+2
x,y=intersection(x1,y1,x2,y2)
assert( | np.array(x) | numpy.array |
import matplotlib.pyplot as plt
import numpy as np
import scipy.sparse.linalg
import time
import datetime
import glob
import os
import platform
import random
from scipy.stats import norm
from scipy.optimize import fsolve
import scipy.stats as st
from nngeometry.layercollection import LayerCollection
from nngeometry.generator import Jacobian
from nngeometry.object import FMatDense
import torch
from torch import autograd
from torch.utils.data import DataLoader, TensorDataset
np.set_printoptions(precision=2)
EPS_BUFFER = 1e-12
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
# def Get_all_relu_layer_output_as_vector(full_model, data_test):
# layer_output_dict = {}
#
# def Get_layer_output(layer_name):
# def hook(model, input, output):
# layer_output_dict[layer_name] = output.detach()
#
# return hook
#
# relu_layer_idx_list = [int(name) for name, layer in full_model.main.named_modules() if isinstance(layer, torch.nn.ReLU)]
# for relu_layer_idx in relu_layer_idx_list:
# full_model.main[relu_layer_idx].register_forward_hook(Get_layer_output(f"main_{relu_layer_idx}"))
#
# output_test = full_model(data_test)
# relu_output_vec = torch.cat([layer_output_dict[relu_layer].view(-1, 1) for relu_layer in layer_output_dict], dim=0)
# return relu_output_vec
def Get_NTK_using_nngeometry(model, out_dim, test_data, centering=True):
# model = G
# out_dim = args.x_dim
# test_data = z_test_torch_no_grad
# centering = True
batch_size = test_data.shape[0]
dataset_test = TensorDataset(test_data, torch.ones(batch_size).to(device))
dataLoader_test = DataLoader(dataset_test, shuffle=False, batch_size=batch_size)
jacobian_generator = Jacobian(layer_collection=LayerCollection.from_model(model),
model=model,
n_output=out_dim,
centering=centering)
ntk_MatDense = FMatDense(jacobian_generator, examples=dataLoader_test)
ntk_torch_tensor = ntk_MatDense.get_dense_tensor()
ntk_torch_mat = ntk_torch_tensor.reshape(ntk_torch_tensor.shape[0] * ntk_torch_tensor.shape[1], -1)
return ntk_torch_mat
def Effective_rank_torch(kernel_mat_torch, eps=1e-12, top_k=None, sparse_eigs=True):
# kernel_mat_torch = ntk_centered
# sparse_eigs = True
if sparse_eigs:
if top_k is None:
top_k = np.min([100, kernel_mat_torch.shape[0]])
kernel_mat_eigvals, _ = scipy.sparse.linalg.eigs(kernel_mat_torch.detach().cpu().numpy(), top_k)
kernel_mat_torch_eigvals_modulus = np.absolute(kernel_mat_eigvals)
else:
kernel_mat_torch_eigvals, _ = torch.eig(kernel_mat_torch)
kernel_mat_torch_eigvals_modulus = np.linalg.norm(kernel_mat_torch_eigvals.detach().cpu().numpy(), axis=1, ord=2)
kernel_mat_torch_eigvals_modulus_normalized = kernel_mat_torch_eigvals_modulus / np.sum(kernel_mat_torch_eigvals_modulus)
kernel_mat_torch_eigvals_modulus_normalized_entropy = -np.sum(kernel_mat_torch_eigvals_modulus_normalized * np.log(kernel_mat_torch_eigvals_modulus_normalized + eps))
kernel_mat_effective_rank = | np.exp(kernel_mat_torch_eigvals_modulus_normalized_entropy) | numpy.exp |
import os, time, sys, io
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.tight_layout as tlt
from iminuit import Minuit, describe
from datetime import datetime
from obspy.signal.detrend import polynomial
import bead_util as bu
import peakdetect as pdet
import dill as pickle
import scipy.optimize as opti
import scipy.signal as signal
import scipy.constants as constants
from tqdm import tqdm
from joblib import Parallel, delayed
n_core = 20
plt.rcParams.update({'font.size': 14})
date = '20200322'
date = '20200924'
# fig_base = '/home/cblakemore/plots/20190626/'
savefig = True
fig_base = '/home/cblakemore/plots/{:s}/spinning/'.format(date)
#fig_base = '/home/cblakemore/plots/spinsim/'
suffix = ''
# suffix = '_less-yrange'
#suffix = '_3_5e-6mbar_110kHz_real-noise'
#dirname = '/data/old_trap_processed/spinning/ringdown/20190626/'
dirname = '/data/old_trap_processed/spinning/ringdown/{:s}/'.format(date)
#dirname = '/data/old_trap_processed/spinning/ringdown_manual/{:s}/'.format(date)
paths, lengths = bu.find_all_fnames(dirname, ext='.p')
newpaths = paths
# # for 20190626:
# newpaths = [paths[1], paths[2]]
# labels = ['Initial', 'Later']
# mbead = 85.0e-15 # convert picograms to kg
# mbead_err = 1.6e-15
priors = False
manual_priors = False
fix_fterm = False
fit_end_time = 3000.0
exp_fit_end_time = 3000.0
two_point_end_time = 3000.0
tau_ylim = (1100, 1400)
# tau_ylim = (1850,2050)
both_two_point = False
err_adjust = 5.0
# newpaths = [#dirname + '100kHz_start_4_all.p', \
# #dirname + '100kHz_start_5_all.p', \
# #dirname + '100kHz_start_6_all.p', \
# #dirname + '100kHz_start_7_all.p', \
# #dirname + '100kHz_start_8_all.p', \
# #dirname + '100kHz_start_9_all.p', \
# #dirname + '100kHz_start_10_all.p', \
# #dirname + '100kHz_start_11_all.p', \
# #dirname + '100kHz_start_12_all.p', \
# #dirname + '100kHz_start_13_all.p', \
# #dirname + '100kHz_start_14_all.p', \
# #dirname + '50kHz_start_1_all.p', \
# #dirname + '50kHz_start_2_all.p', \
# #dirname + '50kHz_start_3_all.p', \
# #dirname + '110kHz_start_1_all.p', \
# #dirname + '110kHz_start_2_all.p', \
# #dirname + '110kHz_start_3_all.p', \
# #dirname + '110kHz_start_4_all.p', \
# #dirname + '110kHz_start_5_all.p', \
# #dirname + '110kHz_start_6_all.p', \
# dirname + '110kHz_start_2_coarse_all.p', \
# dirname + '110kHz_start_3_coarse_all.p', \
# dirname + '110kHz_start_5_coarse_all.p', \
# dirname + '110kHz_start_6_coarse_all.p', \
# ]
newpaths = [\
# os.path.join(dirname, '110kHz_start_1_all.p'), \
os.path.join(dirname, '110kHz_start_2_all.p'), \
os.path.join(dirname, '110kHz_start_3_all.p'), \
]
sim_data = False
sim_path = '/data/old_trap_processed/spinsim_data/spindowns_processed/sim_110kHz_real-noise/'
sim_fig_base = '/home/cblakemore/plots/spinsim/'
sim_suffix = '_3_5e-6mbar_110kHz_real-noise'
paths, lengths = bu.find_all_fnames(sim_path, ext='.p')
sim_prior_data = [0.0, 1]
if sim_data:
newpaths = paths[:50]
labels = []
for pathind, path in enumerate(newpaths):
labels.append('Meas. {:d}'.format(pathind))
def gauss(x, A, mu, sigma, c):
return A * np.exp( -1.0 * (x - mu)**2 / (2.8 * sigma**2)) + c
def ngauss(x, A, mu, sigma, c, n=2):
return A * np.exp(-1.0*np.abs(x-mu)**n / (2.0*sigma**n)) + c
def fit_fun(x, A, mu, sigma):
return ngauss(x, A, mu, sigma, 0, n=5)
#if manual_priors:
# fterm_dirname = '/data/old_trap_processed/spinning/ringdown/20191017/'
fterm_dirname = '/data/old_trap_processed/spinning/ringdown/20200322/'
fterm_paths = [fterm_dirname + 'term_velocity_check_1.npy', \
fterm_dirname + 'term_velocity_check_2.npy', \
#fterm_dirname + 'term_velocity_check_3.npy', \
# fterm_dirname + 'term_velocity_check_4.npy', \
# fterm_dirname + 'term_velocity_check_5.npy', \
# fterm_dirname + 'term_velocity_check_6.npy', \
# fterm_dirname + 'term_velocity_check_7.npy', \
]
all_fterm = []
for pathind, path in enumerate(fterm_paths):
data = np.load(open(path, 'rb'))
#plt.plot(data[1])
#plt.show()
all_fterm += list(data[1])
all_fterm = np.array(all_fterm)
fig_term, ax_term = plt.subplots(1,1,dpi=200)
vals, bin_edge, _ = ax_term.hist(all_fterm, density=True)
bins = bin_edge[:-1] + 0.5*(bin_edge[1] - bin_edge[0])
prior_popt, prior_pcov = opti.curve_fit(fit_fun, bins, vals, maxfev=10000,\
p0=[1, np.mean(all_fterm), np.std(all_fterm)])
plot_x = np.linspace(np.mean(all_fterm)-np.std(all_fterm), \
np.mean(all_fterm)+np.std(all_fterm), 100)
plot_x_2 = np.linspace(np.mean(all_fterm) - 3.0*np.std(all_fterm), \
np.mean(all_fterm) + 3.0*np.std(all_fterm), 100)
ax_term.plot(plot_x, 0.5* | np.max(vals) | numpy.max |
#
# OtterTune - async_tasks.py
#
# Copyright (c) 2017-18, Carnegie Mellon University Database Group
#
import random
import queue
import numpy as np
from celery.task import task, Task
from celery.utils.log import get_task_logger
from djcelery.models import TaskMeta
from sklearn.preprocessing import StandardScaler
from analysis.gp import GPRNP
from analysis.gp_tf import GPRGD
from analysis.preprocessing import Bin, DummyEncoder
from analysis.constraints import ParamConstraintHelper
from website.models import PipelineData, PipelineRun, Result, Workload, KnobCatalog, MetricCatalog
from website.parser import Parser
from website.types import PipelineTaskType
from website.utils import DataUtil, JSONUtil
from website.settings import IMPORTANT_KNOB_NUMBER, NUM_SAMPLES, TOP_NUM_CONFIG # pylint: disable=no-name-in-module
from website.settings import (DEFAULT_LENGTH_SCALE, DEFAULT_MAGNITUDE,
MAX_TRAIN_SIZE, BATCH_SIZE, NUM_THREADS,
DEFAULT_RIDGE, DEFAULT_LEARNING_RATE,
DEFAULT_EPSILON, MAX_ITER, GPR_EPS,
DEFAULT_SIGMA_MULTIPLIER, DEFAULT_MU_MULTIPLIER)
from website.settings import INIT_FLIP_PROB, FLIP_PROB_DECAY
from website.types import VarType
LOG = get_task_logger(__name__)
class UpdateTask(Task): # pylint: disable=abstract-method
def __init__(self):
self.rate_limit = '50/m'
self.max_retries = 3
self.default_retry_delay = 60
class AggregateTargetResults(UpdateTask): # pylint: disable=abstract-method
def on_success(self, retval, task_id, args, kwargs):
super(AggregateTargetResults, self).on_success(retval, task_id, args, kwargs)
# Completely delete this result because it's huge and not
# interesting
task_meta = TaskMeta.objects.get(task_id=task_id)
task_meta.result = None
task_meta.save()
class MapWorkload(UpdateTask): # pylint: disable=abstract-method
def on_success(self, retval, task_id, args, kwargs):
super(MapWorkload, self).on_success(retval, task_id, args, kwargs)
# Replace result with formatted result
if not args[0]['bad']:
new_res = {
'scores': sorted(args[0]['scores'].items()),
'mapped_workload_id': args[0]['mapped_workload'],
}
task_meta = TaskMeta.objects.get(task_id=task_id)
task_meta.result = new_res # Only store scores
task_meta.save()
else:
task_meta = TaskMeta.objects.get(task_id=task_id)
task_meta.result = None
task_meta.save()
class ConfigurationRecommendation(UpdateTask): # pylint: disable=abstract-method
def on_success(self, retval, task_id, args, kwargs):
super(ConfigurationRecommendation, self).on_success(retval, task_id, args, kwargs)
result_id = args[0]['newest_result_id']
result = Result.objects.get(pk=result_id)
# Replace result with formatted result
formatted_params = Parser.format_dbms_knobs(result.dbms.pk, retval['recommendation'])
task_meta = TaskMeta.objects.get(task_id=task_id)
retval['recommendation'] = formatted_params
task_meta.result = retval
task_meta.save()
# Create next configuration to try
config = Parser.create_knob_configuration(result.dbms.pk, retval['recommendation'])
retval['recommendation'] = config
result.next_configuration = JSONUtil.dumps(retval)
result.save()
@task(base=AggregateTargetResults, name='aggregate_target_results')
def aggregate_target_results(result_id):
# Check that we've completed the background tasks at least once. We need
# this data in order to make a configuration recommendation (until we
# implement a sampling technique to generate new training data).
latest_pipeline_run = PipelineRun.objects.get_latest()
newest_result = Result.objects.get(pk=result_id)
if latest_pipeline_run is None or newest_result.session.tuning_session == 'randomly_generate':
result = Result.objects.filter(pk=result_id)
knobs_ = KnobCatalog.objects.filter(dbms=result[0].dbms, tunable=True)
knobs_catalog = {k.name: k for k in knobs_}
knobs = {k: v for k, v in
list(knobs_catalog.items())}
# generate a config randomly
random_knob_result = gen_random_data(knobs)
agg_data = DataUtil.aggregate_data(result)
agg_data['newest_result_id'] = result_id
agg_data['bad'] = True
agg_data['config_recommend'] = random_knob_result
return agg_data
# Aggregate all knob config results tried by the target so far in this
# tuning session and this tuning workload.
target_results = Result.objects.filter(session=newest_result.session,
dbms=newest_result.dbms,
workload=newest_result.workload)
if len(target_results) == 0:
raise Exception('Cannot find any results for session_id={}, dbms_id={}'
.format(newest_result.session, newest_result.dbms))
agg_data = DataUtil.aggregate_data(target_results)
agg_data['newest_result_id'] = result_id
agg_data['bad'] = False
return agg_data
def gen_random_data(knobs):
random_knob_result = {}
for name, metadata in list(knobs.items()):
if metadata.vartype == VarType.BOOL:
flag = random.randint(0, 1)
if flag == 0:
random_knob_result[name] = False
else:
random_knob_result[name] = True
elif metadata.vartype == VarType.ENUM:
enumvals = metadata.enumvals.split(',')
enumvals_len = len(enumvals)
rand_idx = random.randint(0, enumvals_len - 1)
random_knob_result[name] = rand_idx
elif metadata.vartype == VarType.INTEGER:
random_knob_result[name] = random.randint(int(metadata.minval), int(metadata.maxval))
elif metadata.vartype == VarType.REAL:
random_knob_result[name] = random.uniform(
float(metadata.minval), float(metadata.maxval))
elif metadata.vartype == VarType.STRING:
random_knob_result[name] = "None"
elif metadata.vartype == VarType.TIMESTAMP:
random_knob_result[name] = "None"
else:
raise Exception(
'Unknown variable type: {}'.format(metadata.vartype))
return random_knob_result
@task(base=ConfigurationRecommendation, name='configuration_recommendation')
def configuration_recommendation(target_data):
LOG.info('configuration_recommendation called')
latest_pipeline_run = PipelineRun.objects.get_latest()
if target_data['bad'] is True:
target_data_res = {}
target_data_res['status'] = 'bad'
target_data_res['info'] = 'WARNING: no training data, the config is generated randomly'
target_data_res['recommendation'] = target_data['config_recommend']
return target_data_res
# Load mapped workload data
mapped_workload_id = target_data['mapped_workload'][0]
mapped_workload = Workload.objects.get(pk=mapped_workload_id)
workload_knob_data = PipelineData.objects.get(
pipeline_run=latest_pipeline_run,
workload=mapped_workload,
task_type=PipelineTaskType.KNOB_DATA)
workload_knob_data = JSONUtil.loads(workload_knob_data.data)
workload_metric_data = PipelineData.objects.get(
pipeline_run=latest_pipeline_run,
workload=mapped_workload,
task_type=PipelineTaskType.METRIC_DATA)
workload_metric_data = JSONUtil.loads(workload_metric_data.data)
X_workload = np.array(workload_knob_data['data'])
X_columnlabels = np.array(workload_knob_data['columnlabels'])
y_workload = np.array(workload_metric_data['data'])
y_columnlabels = np.array(workload_metric_data['columnlabels'])
rowlabels_workload = np.array(workload_metric_data['rowlabels'])
# Target workload data
newest_result = Result.objects.get(pk=target_data['newest_result_id'])
X_target = target_data['X_matrix']
y_target = target_data['y_matrix']
rowlabels_target = np.array(target_data['rowlabels'])
if not np.array_equal(X_columnlabels, target_data['X_columnlabels']):
raise Exception(('The workload and target data should have '
'identical X columnlabels (sorted knob names)'))
if not np.array_equal(y_columnlabels, target_data['y_columnlabels']):
raise Exception(('The workload and target data should have '
'identical y columnlabels (sorted metric names)'))
# Filter Xs by top 10 ranked knobs
ranked_knobs = PipelineData.objects.get(
pipeline_run=latest_pipeline_run,
workload=mapped_workload,
task_type=PipelineTaskType.RANKED_KNOBS)
ranked_knobs = JSONUtil.loads(ranked_knobs.data)[:IMPORTANT_KNOB_NUMBER]
ranked_knob_idxs = [i for i, cl in enumerate(X_columnlabels) if cl in ranked_knobs]
X_workload = X_workload[:, ranked_knob_idxs]
X_target = X_target[:, ranked_knob_idxs]
X_columnlabels = X_columnlabels[ranked_knob_idxs]
# Filter ys by current target objective metric
target_objective = newest_result.session.target_objective
target_obj_idx = [i for i, cl in enumerate(y_columnlabels) if cl == target_objective]
if len(target_obj_idx) == 0:
raise Exception(('Could not find target objective in metrics '
'(target_obj={})').format(target_objective))
elif len(target_obj_idx) > 1:
raise Exception(('Found {} instances of target objective in '
'metrics (target_obj={})').format(len(target_obj_idx),
target_objective))
metric_meta = MetricCatalog.objects.get_metric_meta(newest_result.session.dbms,
newest_result.session.target_objective)
if metric_meta[target_objective].improvement == '(less is better)':
lessisbetter = True
else:
lessisbetter = False
y_workload = y_workload[:, target_obj_idx]
y_target = y_target[:, target_obj_idx]
y_columnlabels = y_columnlabels[target_obj_idx]
# Combine duplicate rows in the target/workload data (separately)
X_workload, y_workload, rowlabels_workload = DataUtil.combine_duplicate_rows(
X_workload, y_workload, rowlabels_workload)
X_target, y_target, rowlabels_target = DataUtil.combine_duplicate_rows(
X_target, y_target, rowlabels_target)
# Delete any rows that appear in both the workload data and the target
# data from the workload data
dups_filter = np.ones(X_workload.shape[0], dtype=bool)
target_row_tups = [tuple(row) for row in X_target]
for i, row in enumerate(X_workload):
if tuple(row) in target_row_tups:
dups_filter[i] = False
X_workload = X_workload[dups_filter, :]
y_workload = y_workload[dups_filter, :]
rowlabels_workload = rowlabels_workload[dups_filter]
# Combine target & workload Xs for preprocessing
X_matrix = np.vstack([X_target, X_workload])
# Dummy encode categorial variables
categorical_info = DataUtil.dummy_encoder_helper(X_columnlabels,
mapped_workload.dbms)
dummy_encoder = DummyEncoder(categorical_info['n_values'],
categorical_info['categorical_features'],
categorical_info['cat_columnlabels'],
categorical_info['noncat_columnlabels'])
X_matrix = dummy_encoder.fit_transform(X_matrix)
# below two variables are needed for correctly determing max/min on dummies
binary_index_set = set(categorical_info['binary_vars'])
total_dummies = dummy_encoder.total_dummies()
# Scale to N(0, 1)
X_scaler = StandardScaler()
X_scaled = X_scaler.fit_transform(X_matrix)
if y_target.shape[0] < 5: # FIXME
# FIXME (dva): if there are fewer than 5 target results so far
# then scale the y values (metrics) using the workload's
# y_scaler. I'm not sure if 5 is the right cutoff.
y_target_scaler = None
y_workload_scaler = StandardScaler()
y_matrix = np.vstack([y_target, y_workload])
y_scaled = y_workload_scaler.fit_transform(y_matrix)
else:
# FIXME (dva): otherwise try to compute a separate y_scaler for
# the target and scale them separately.
try:
y_target_scaler = StandardScaler()
y_workload_scaler = StandardScaler()
y_target_scaled = y_target_scaler.fit_transform(y_target)
y_workload_scaled = y_workload_scaler.fit_transform(y_workload)
y_scaled = np.vstack([y_target_scaled, y_workload_scaled])
except ValueError:
y_target_scaler = None
y_workload_scaler = StandardScaler()
y_scaled = y_workload_scaler.fit_transform(y_target)
# Set up constraint helper
constraint_helper = ParamConstraintHelper(scaler=X_scaler,
encoder=dummy_encoder,
binary_vars=categorical_info['binary_vars'],
init_flip_prob=INIT_FLIP_PROB,
flip_prob_decay=FLIP_PROB_DECAY)
# FIXME (dva): check if these are good values for the ridge
# ridge = np.empty(X_scaled.shape[0])
# ridge[:X_target.shape[0]] = 0.01
# ridge[X_target.shape[0]:] = 0.1
# FIXME: we should generate more samples and use a smarter sampling
# technique
num_samples = NUM_SAMPLES
X_samples = np.empty((num_samples, X_scaled.shape[1]))
X_min = np.empty(X_scaled.shape[1])
X_max = np.empty(X_scaled.shape[1])
knobs_mem = KnobCatalog.objects.filter(
dbms=newest_result.session.dbms, tunable=True, resource=1)
knobs_mem_catalog = {k.name: k for k in knobs_mem}
mem_max = newest_result.workload.hardware.memory
X_mem = np.zeros([1, X_scaled.shape[1]])
X_default = np.empty(X_scaled.shape[1])
# Get default knob values
for i, k_name in enumerate(X_columnlabels):
k = KnobCatalog.objects.filter(dbms=newest_result.session.dbms, name=k_name)[0]
X_default[i] = k.default
X_default_scaled = X_scaler.transform(X_default.reshape(1, X_default.shape[0]))[0]
# Determine min/max for knob values
for i in range(X_scaled.shape[1]):
if i < total_dummies or i in binary_index_set:
col_min = 0
col_max = 1
else:
col_min = X_scaled[:, i].min()
col_max = X_scaled[:, i].max()
if X_columnlabels[i] in knobs_mem_catalog:
X_mem[0][i] = mem_max * 1024 * 1024 * 1024 # mem_max GB
col_max = min(col_max, X_scaler.transform(X_mem)[0][i])
# Set min value to the default value
# FIXME: support multiple methods can be selected by users
col_min = X_default_scaled[i]
X_min[i] = col_min
X_max[i] = col_max
X_samples[:, i] = np.random.rand(num_samples) * (col_max - col_min) + col_min
# Maximize the throughput, moreisbetter
# Use gradient descent to minimize -throughput
if not lessisbetter:
y_scaled = -y_scaled
q = queue.PriorityQueue()
for x in range(0, y_scaled.shape[0]):
q.put((y_scaled[x][0], x))
i = 0
while i < TOP_NUM_CONFIG:
try:
item = q.get_nowait()
# Tensorflow get broken if we use the training data points as
# starting points for GPRGD. We add a small bias for the
# starting points. GPR_EPS default value is 0.001
# if the starting point is X_max, we minus a small bias to
# make sure it is within the range.
dist = sum(np.square(X_max - X_scaled[item[1]]))
if dist < 0.001:
X_samples = np.vstack((X_samples, X_scaled[item[1]] - abs(GPR_EPS)))
else:
X_samples = np.vstack((X_samples, X_scaled[item[1]] + abs(GPR_EPS)))
i = i + 1
except queue.Empty:
break
model = GPRGD(length_scale=DEFAULT_LENGTH_SCALE,
magnitude=DEFAULT_MAGNITUDE,
max_train_size=MAX_TRAIN_SIZE,
batch_size=BATCH_SIZE,
num_threads=NUM_THREADS,
learning_rate=DEFAULT_LEARNING_RATE,
epsilon=DEFAULT_EPSILON,
max_iter=MAX_ITER,
sigma_multiplier=DEFAULT_SIGMA_MULTIPLIER,
mu_multiplier=DEFAULT_MU_MULTIPLIER)
model.fit(X_scaled, y_scaled, X_min, X_max, ridge=DEFAULT_RIDGE)
res = model.predict(X_samples, constraint_helper=constraint_helper)
best_config_idx = np.argmin(res.minl.ravel())
best_config = res.minl_conf[best_config_idx, :]
best_config = X_scaler.inverse_transform(best_config)
# Decode one-hot encoding into categorical knobs
best_config = dummy_encoder.inverse_transform(best_config)
# Although we have max/min limits in the GPRGD training session, it may
# lose some precisions. e.g. 0.99..99 >= 1.0 may be True on the scaled data,
# when we inversely transform the scaled data, the different becomes much larger
# and cannot be ignored. Here we check the range on the original data
# directly, and make sure the recommended config lies within the range
X_min_inv = X_scaler.inverse_transform(X_min)
X_max_inv = X_scaler.inverse_transform(X_max)
best_config = np.minimum(best_config, X_max_inv)
best_config = np.maximum(best_config, X_min_inv)
conf_map = {k: best_config[i] for i, k in enumerate(X_columnlabels)}
conf_map_res = {}
conf_map_res['status'] = 'good'
conf_map_res['recommendation'] = conf_map
conf_map_res['info'] = 'INFO: training data size is {}'.format(X_scaled.shape[0])
return conf_map_res
def load_data_helper(filtered_pipeline_data, workload, task_type):
pipeline_data = filtered_pipeline_data.get(workload=workload,
task_type=task_type)
LOG.debug("PIPELINE DATA: %s", str(pipeline_data.data))
return JSONUtil.loads(pipeline_data.data)
@task(base=MapWorkload, name='map_workload')
def map_workload(target_data):
# Get the latest version of pipeline data that's been computed so far.
latest_pipeline_run = PipelineRun.objects.get_latest()
if target_data['bad']:
assert target_data is not None
return target_data
assert latest_pipeline_run is not None
newest_result = Result.objects.get(pk=target_data['newest_result_id'])
target_workload = newest_result.workload
X_columnlabels = | np.array(target_data['X_columnlabels']) | numpy.array |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Nov 12 00:17:13 2021
@author: alankar
"""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
from scipy.integrate import solve_ivp
import h5py
import sys
from scipy import interpolate
import sys
from decimal import Decimal
def fexp(number):
(sign, digits, exponent) = Decimal(number).as_tuple()
return len(digits) + exponent - 1
def fman(number):
return Decimal(number).scaleb(-fexp(number)).normalize()
Msun = 2e33
yr = 365*24*60**2
mp = 1.6726219e-24
kB = 1.380649e-16
pc = 3.086e18
kpc = 1e3*pc
X = 0.7154
Y = 0.2703
Z = 0.0143
mu = 1./(2*X+0.75*Y+0.5625*Z)
mue = 2./(1+X)
mui = 1./(1/mu-1/mue)
Tfloor = 1.e4
def deriv(x, y):
if y[0]>0:
print ("negative density!",x)
#sys.exit()
d = np.abs(-1./(y[0]*x**q))
if d<=0: d = -d
p = y[1]*d**gamma # tilde density and pressure
T = mu*mp*c0*c0*p/(kB*d*gamma) # temperature in CGS
Lam = Lambda(T)/Lam0 #tilde Lambda
if (T<=Tfloor):
T = Tfloor
Lam = 0. #Lambda(T)*(T/Tfloor)**(-10.)/Lam0
Num1 = q*(c0/v0)**2*( d*Lam*(1+gamma_m/(gamma*beta0))/y[0] + (p+gamma_m*d**gamma_m/(gamma*beta0))/(x*d) )
Den1 = (1 - (c0/v0)**2*(p+gamma_m*d**gamma_m/(gamma*beta0))/(d*y[0]**2))*y[0]
return [ Num1/Den1, -q*gamma*(1+gamma_m/(gamma*beta0))*Lam*d**(2-gamma)/y[0] ]
def Lambda(temp): #returns cooling function in cgs
klo=0; khi=tab_sz-1
while (klo != (khi-1)):
kmid = int((khi+klo)/2)
Tmid = Ttab[kmid]
if (temp<=Tmid):
khi = kmid
if (temp>Tmid):
klo = kmid
dT = Ttab[khi] - Ttab[klo]
scrh = Ltab[klo]*(Ttab[khi]-temp)/dT + Ltab[khi]*(temp-Ttab[klo])/dT; #linear interpolation
return scrh
'''
def Lambda(temp):
lam = 0.0
if (temp<=1.e7 and temp>=1.e4):
lam = 2.7e-23*(temp/1.e7)**-1.0
if (temp<1.e4):
lam = 2.7e-20*(temp/1.e4)**20
#lam = 1.e-100
if (temp>1.e7):
lam = 2.7e-23*(temp/1.e7)**-20
#lam = 1.e-100
return lam
'''
D = np.loadtxt('./cooltable.dat')
global Ttab, Ltab, tab_sz
Ttab = D[:,0]; Ltab = D[:,1]; tab_sz = np.size(Ttab)
global q, gamma, gamma_m, beta0, c0, v0, Lam0, T0, d0, v0byc0
gamma_m = 1.03; beta0 = 1e10
q=2; gamma=5./3.
mu = 0.62; mue = 1.17; mui = 1./(1./mu - 1./mue)
#v0byc0 = 0.099; T0 = 5.1e5; d0 = 1.96e-3*mu*mp ; c0 = np.sqrt(gamma*kB*T0/mu/mp)
#v0byc0 = 0.049; T0 = 3.8e5; d0 = 7.9e-4*mu*mp ; c0 = np.sqrt(gamma*kB*T0/mu/mp)
for logT0 in np.linspace(4,7,1000):
for logn0 in np.linspace(-4,-1,1000):
v0byc0 = 0.05; T0 = 10**logT0; d0 = (10**logn0)*mu*mp ; c0 = np.sqrt(gamma*kB*T0/mu/mp) #5kpc
shift = 1.0
ct0=c0* | np.sqrt(1+gamma_m/(gamma*beta0)) | numpy.sqrt |
import os.path
import cv2
import numpy as np
class DepthTracker:
def __init__(self, intrinsic_matrix, scale_factor=1.0, coordinate=None):
self.scale_factor = scale_factor
self.fx = intrinsic_matrix[0, 0] * scale_factor
self.fy = intrinsic_matrix[1, 1] * scale_factor
self.cx = intrinsic_matrix[0, 2] * scale_factor
self.cy = intrinsic_matrix[1, 2] * scale_factor
self.coordinate = coordinate
def compute_dist(self, new_coord):
if self.coordinate is None:
self.coordinate = new_coord
return 0
dist = np.linalg.norm(new_coord - self.coordinate)
self.coordinate = new_coord
return dist
def get_coordinates(self, x1, y1, depth):
print(f"depth at center: {depth}")
x = (x1 - self.cx) * depth / self.fx
y = (y1 - self.cy) * depth / self.fy
result = np.array([x, y, depth])
return result
def get_coords_bb(self, img_name):
input_img = cv2.resize(cv2.imread(f"./input/{img_name}.jpg"), (0, 0), fx=self.scale_factor, fy=self.scale_factor)
bounding_box = cv2.selectROI('frame', input_img, fromCenter=False, showCrosshair=True)
center_x, center_y, height_pixels = bounding_box[0], bounding_box[1], bounding_box[3]
return self.get_coordinates(center_x, center_y, 7.38)
if __name__ == "__main__":
intrinsic_matrix = np.loadtxt('../camera_calibration/intrinsics.cfg')
depth_tracker = DepthTracker(intrinsic_matrix, scale_factor=0.25)
prev_coords = None
for image in ["PXL_20210418_183601908", "PXL_20210418_183618429"]:
coords = depth_tracker.get_coords_bb(image) # 6.63
print(f"in image {image} richard is at {coords}")
if prev_coords is not None:
dist = | np.linalg.norm(prev_coords - coords) | numpy.linalg.norm |
"""
Copyright (c) 2018-2022 Intel Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import numpy as np
from ..utils import remove_difficult
from .base_representation import BaseRepresentation
class Detection(BaseRepresentation):
def __init__(self, identifier='', labels=None, x_mins=None, y_mins=None, x_maxs=None, y_maxs=None, metadata=None):
super().__init__(identifier, metadata)
self.labels = np.array(labels) if labels is not None else np.array([])
self.x_mins = np.array(x_mins) if x_mins is not None else np.array([])
self.y_mins = np.array(y_mins) if y_mins is not None else np.array([])
self.x_maxs = np.array(x_maxs) if x_maxs is not None else np.array([])
self.y_maxs = np.array(y_maxs) if y_maxs is not None else np.array([])
def remove(self, indexes):
self.labels = np.delete(self.labels, indexes)
self.x_mins = np.delete(self.x_mins, indexes)
self.y_mins = np.delete(self.y_mins, indexes)
self.x_maxs = np.delete(self.x_maxs, indexes)
self.y_maxs = np.delete(self.y_maxs, indexes)
difficult_boxes = self.metadata.get('difficult_boxes')
if not difficult_boxes:
return
new_difficult_boxes = remove_difficult(difficult_boxes, indexes)
self.metadata['difficult_boxes'] = new_difficult_boxes
@property
def size(self):
return len(self.x_mins)
@property
def boxes(self):
if self.size == 0:
return []
return [[x_min, y_min, x_max, y_max]
for x_min, y_min, x_max, y_max in zip(self.x_mins, self.y_mins, self.x_maxs, self.y_maxs)]
def __eq__(self, other):
if not isinstance(other, type(self)):
return False
def are_bounding_boxes_equal():
if not np.array_equal(self.labels, other.labels):
return False
if not np.array_equal(self.x_mins, other.x_mins):
return False
if not np.array_equal(self.y_mins, other.y_mins):
return False
if not | np.array_equal(self.x_maxs, other.x_maxs) | numpy.array_equal |
import os
from copy import deepcopy
import pickle
import argparse
import re
from distutils.util import strtobool
import numpy as np
import psutil
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from transformers import AutoTokenizer, get_constant_schedule_with_warmup
from torch.utils.tensorboard import SummaryWriter
from models.seqtransformer import SeqTransformer
from data.meta_dataset import meta_dataset
from data.utils.tokenizer import manual_tokenizer, specials
from data.utils.data_loader_numpy import StratifiedLoader, StratifiedLoaderwClassesSubset
from data.utils.sampling import dataset_sampler
from utils.metrics import logging_metrics
from utils.timing import Timer
from utils.seed import set_seed
def train(args):
def _get_dataloader(datasubset, tokenizer, device, args, subset_classes=True):
"""
Get specific dataloader.
Args:
datasubset ([type]): [description]
tokenizer ([type]): [description]
device ([type]): [description]
args ([type]): [description]
Returns:
dataloader
"""
if subset_classes:
dataloader = StratifiedLoaderwClassesSubset(datasubset, k=args['k'],
max_classes=args['max_classes'],
max_batch_size=args['max_batch_size'],
tokenizer=tokenizer,
device=device,
shuffle=True,
verbose=False)
else:
dataloader = StratifiedLoader(datasubset, k=args['k'],
max_batch_size=args['max_batch_size'],
tokenizer=tokenizer,
device=device,
shuffle=True,
verbose=False)
return dataloader
def _adapt_and_fit(support_labels, support_input, query_labels, query_input, loss_fn, model_init, args, mode="train"):
"""
Adapts the init model to a support set and computes loss on query set.
Args:
support_labels ([type]): [description]
support_text ([type]): [description]
query_labels ([type]): [description]
query_text ([type]): [description]
model_init ([type]): [description]
args
mode
"""
#####################
# Create model_task #
#####################
if (not args['dropout']) and mode == "train":
for module in model_init.modules():
if isinstance(module, nn.Dropout):
module.eval()
else:
module.train()
elif mode != "train":
model_init.eval()
else:
model_init.train()
model_task = deepcopy(model_init)
model_task_optimizer = optim.SGD(model_task.parameters(),
lr=args['inner_lr'])
model_task.zero_grad()
#######################
# Generate prototypes #
#######################
y = model_init(support_input)
labs = torch.sort(torch.unique(support_labels))[0]
prototypes = torch.stack([torch.mean(y[support_labels == c], dim=0) for c in labs])
W_init = 2 * prototypes
b_init = -torch.norm(prototypes, p=2, dim=1)**2
W_task, b_task = W_init.detach(), b_init.detach()
W_task.requires_grad, b_task.requires_grad = True, True
#################
# Adapt to data #
#################
for _ in range(args['n_inner']):
y = model_task(support_input)
logits = F.linear(y, W_task, b_task)
inner_loss = loss_fn(logits, support_labels)
W_task_grad, b_task_grad = torch.autograd.grad(inner_loss,\
[W_task, b_task], retain_graph=True)
inner_loss.backward()
if args['clip_val'] > 0:
torch.nn.utils.clip_grad_norm_(model_task.parameters(),
args['clip_val'])
model_task_optimizer.step()
W_task = W_task - args['output_lr'] * W_task_grad
b_task = b_task - args['output_lr'] * b_task_grad
if args['print_inner_loss']:
print(f"\tInner Loss: {inner_loss.detach().cpu().item()}")
#########################
# Validate on query set #
#########################
if mode == "train":
for module in model_task.modules():
if isinstance(module, nn.Dropout):
module.eval()
W_task = W_init + (W_task - W_init).detach()
b_task = b_init + (b_task - b_init).detach()
y = model_task(query_input)
logits = F.linear(y, W_task, b_task)
outer_loss = loss_fn(logits, query_labels)
if mode == "train":
model_task_params = [param for param in model_task.parameters() if param.requires_grad]
model_task_grads = torch.autograd.grad(outer_loss, model_task_params,
retain_graph=True)
model_init_params = [param for param in model_init.parameters() if param.requires_grad]
model_init_grads = torch.autograd.grad(outer_loss, model_init_params,
retain_graph=False)
model_init_grads = model_init_grads + model_task_grads
for param, grad in zip(model_init_params, model_init_grads):
if param.grad != None:
param.grad += grad.detach()
else:
param.grad = grad.detach()
else:
del model_task, W_task, b_task, W_task_grad, b_task_grad, prototypes, W_init, b_init
if outer_loss.detach().cpu().item() > 10:
print(outer_loss.detach().cpu().item(),
inner_loss.detach().cpu().item())
return logits.detach(), outer_loss.detach()
#######################
# Logging Directories #
#######################
log_dir = os.path.join(args['checkpoint_path'], args['version'])
os.makedirs(log_dir, exist_ok=True)
os.makedirs(os.path.join(log_dir, 'tensorboard'), exist_ok=True)
os.makedirs(os.path.join(log_dir, 'checkpoint'), exist_ok=True)
#print(f"Saving models and logs to {log_dir}")
checkpoint_save_path = os.path.join(log_dir, 'checkpoint')
with open(os.path.join(log_dir, 'checkpoint', 'hparams.pickle'), 'wb') as file:
pickle.dump(args, file)
##########################
# Device, Logging, Timer #
##########################
set_seed(args['seed'])
timer = Timer()
device = torch.device('cuda' if (torch.cuda.is_available() and args['gpu']) else 'cpu')
# Build the tensorboard writer
writer = SummaryWriter(os.path.join(log_dir, 'tensorboard'))
###################
# Load in dataset #
###################
print("Data Prep")
dataset = meta_dataset(include=args['include'], verbose=True)
dataset.prep(text_tokenizer=manual_tokenizer)
print("")
####################
# Init models etc. #
####################
model_init = SeqTransformer(args)
tokenizer = AutoTokenizer.from_pretrained(args['encoder_name'])
tokenizer.add_special_tokens({'additional_special_tokens': specials()})
model_init.encoder.model.resize_token_embeddings(len(tokenizer.vocab))
if args['optimizer'] == "Adam":
meta_optimizer = optim.Adam(model_init.parameters(), lr=args['meta_lr'])
elif args['optimizer'] == "SGD":
meta_optimizer = optim.SGD(model_init.parameters(), lr=args['meta_lr'])
meta_scheduler = get_constant_schedule_with_warmup(meta_optimizer, args['warmup_steps'])
reduceOnPlateau = optim.lr_scheduler.ReduceLROnPlateau(meta_optimizer, mode='max',
factor=args['lr_reduce_factor'],
patience=args['patience'],
verbose=True)
model_init = model_init.to(device)
loss_fn = nn.CrossEntropyLoss()
#################
# Training loop #
#################
best_overall_acc_s = 0.0
for episode in range(1, args['max_episodes']+1):
outer_loss_agg, acc_agg, f1_agg = 0.0, 0.0, 0.0
outer_loss_s_agg, acc_s_agg, f1_s_agg = 0.0, 0.0, 0.0
for ii in range(1, args['n_outer']+1):
#################
# Sample a task #
#################
task = dataset_sampler(dataset, sampling_method='sqrt')
datasubset = dataset.datasets[task]['train']
dataloader = _get_dataloader(datasubset, tokenizer, device,
args, subset_classes=args['subset_classes'])
support_labels, support_input, query_labels, query_input = next(dataloader)
logits, outer_loss = _adapt_and_fit(support_labels, support_input,
query_labels, query_input,
loss_fn, model_init, args,
mode="train")
######################
# Inner Loop Logging #
######################
with torch.no_grad():
mets = logging_metrics(logits.detach().cpu(), query_labels.detach().cpu())
outer_loss_ = outer_loss.detach().cpu().item()
acc = mets['acc']
f1 = mets['f1']
outer_loss_s = outer_loss_/ np.log(dataloader.n_classes)
acc_s = acc / (1/dataloader.n_classes)
f1_s = f1/(1/dataloader.n_classes)
outer_loss_agg += outer_loss_ / args['n_outer']
acc_agg += acc / args['n_outer']
f1_agg += f1 / args['n_outer']
outer_loss_s_agg += outer_loss_s / args['n_outer']
acc_s_agg += acc_s / args['n_outer']
f1_s_agg += f1_s / args['n_outer']
print("{:} | Train | Episode {:04}.{:02} | Task {:^20s}, N={:} | Loss {:5.2f}, Acc {:5.2f}, F1 {:5.2f} | Mem {:5.2f} GB".format(
timer.dt(), episode, ii, task, dataloader.n_classes,
outer_loss_s if args['print_scaled'] else outer_loss_,
acc_s if args['print_scaled'] else acc,
f1_s if args['print_scaled'] else f1,
psutil.Process(os.getpid()).memory_info().rss / 1024 ** 3))
writer.add_scalars('Loss/Train', {task: outer_loss_}, episode)
writer.add_scalars('Accuracy/Train', {task: acc}, episode)
writer.add_scalars('F1/Train', {task: f1}, episode)
writer.add_scalars('LossScaled/Train', {task: outer_loss_s}, episode)
writer.add_scalars('AccuracyScaled/Train', {task: acc_s}, episode)
writer.add_scalars('F1Scaled/Train', {task: f1_s}, episode)
writer.flush()
############################
# Init Model Backward Pass #
############################
model_init_params = [param for param in model_init.parameters() if param.requires_grad]
#for param in model_init_params:
# param.grad = param.grad #/ args['n_outer']
if args['clip_val'] > 0:
torch.nn.utils.clip_grad_norm_(model_init_params, args['clip_val'])
meta_optimizer.step()
meta_scheduler.step()
if args['warmup_steps'] <= episode + 1:
meta_optimizer.zero_grad()
#####################
# Aggregate Logging #
#####################
print("{:} | MACRO-AGG | Train | Episode {:04} | Loss {:5.2f}, Acc {:5.2f}, F1 {:5.2f}\n".format(
timer.dt(), episode,
outer_loss_s_agg if args['print_scaled'] else outer_loss_agg,
acc_s_agg if args['print_scaled'] else acc_agg,
f1_s_agg if args['print_scaled'] else f1_agg))
writer.add_scalar('Loss/MacroTrain', outer_loss_agg, episode)
writer.add_scalar('Accuracy/MacroTrain', acc_agg, episode)
writer.add_scalar('F1/MacroTrain', f1_agg, episode)
writer.add_scalar('LossScaled/MacroTrain', outer_loss_s_agg, episode)
writer.add_scalar('AccuracyScaled/MacroTrain', acc_s_agg, episode)
writer.add_scalar('F1Scaled/MacroTrain', f1_s_agg, episode)
writer.flush()
##############
# Evaluation #
##############
if (episode % args['eval_every_n']) == 0 or episode==1:
overall_loss, overall_acc, overall_f1 = [], [], []
overall_loss_s, overall_acc_s, overall_f1_s = [], [], []
###################
# Individual Task #
###################
for task in dataset.lens.keys():
datasubset = dataset.datasets[task]['validation']
task_loss, task_acc, task_f1 = [], [], []
task_loss_s, task_acc_s, task_f1_s = [], [], []
for _ in range(args['n_eval_per_task']):
dataloader = _get_dataloader(datasubset, tokenizer, device,
args, subset_classes=args['subset_classes'])
support_labels, support_input, query_labels, query_input = next(dataloader)
logits, loss = _adapt_and_fit(support_labels, support_input,
query_labels, query_input,
loss_fn, model_init, args,
mode="eval")
mets = logging_metrics(logits.detach().cpu(), query_labels.detach().cpu())
task_loss.append(loss.detach().cpu().item())
task_acc.append(mets['acc'])
task_f1.append(mets['f1'])
task_loss_s.append(loss.detach().cpu().item() / | np.log(dataloader.n_classes) | numpy.log |
import numpy as np
import numpy.random
import matplotlib.pyplot as plt
import acivate_fun as act
from generate_data import get_normal_data, get_simple_data
from numpy import seterr
import init_utils # 第一部分，初始化
seterr(all='raise')
# 设置常量
# 激活函数的标识字符串
SIGMOID_NAME = 'sigmoid'
TANH_NAME = 'tanh'
RELU_NAME = 'ReLU'
# 深层神经网络主驱动
# net_array = 深度数组，如 [{'neurons': 3, 'activate': 'tanh'}]
# learning_rate = 学习率，默认为 0.12
# train_times = 训练次数，默认为 3000
# random_seed = 随机数的种子，默认为 2021
def deep_neural_network(X, Y
, net_array, learning_rate=0.12
, train_times=3000, random_seed=2021):
# 绘图
x = []
y = []
# 初始化基本参数
net_deep = len(net_array)
net_array[0]['neurons'] = X.shape[0]
numpy.random.seed(random_seed)
m = X.shape[1]
W, b = initial_parameters(net_array)
# 对每一个深度的参数进行保存
Z = [ | np.array([]) | numpy.array |
"""Utility module."""
import numpy as np
import astropy.constants as const
import astropy.units as u
from scipy.interpolate import RectBivariateSpline
from typing import Sequence, Optional, Tuple, Union
import warnings
from .interpolators import Beam
def _get_bl_len_vec(bl_len_ns: Union[float, np.ndarray]) -> np.ndarray:
"""
Convert a baseline length in a variety of formats to a standard length-3 vector.
Parameters
----------
bl_len_ns
The baseline length in nanosec (i.e. 1e9 * metres / c). If scalar, interpreted
as E-W length, if len(2), interpreted as EW and NS length, otherwise the full
[EW, NS, Z] length. Unspecified dimensions are assumed to be zero.
Returns
-------
bl_vec
A length-3 array. The full [EW, NS, Z] baseline vector.
"""
if np.isscalar(bl_len_ns):
return np.array([bl_len_ns, 0, 0])
elif len(bl_len_ns) <= 3:
# make a length-3 array
return np.pad(bl_len_ns, pad_width=3 - len(bl_len_ns), mode="constant")[-3:]
return bl_len_ns
def get_bl_len_magnitude(bl_len_ns: Union[float, np.ndarray, Sequence]) -> float:
"""
Get the magnitude of the length of the given baseline.
Parameters
----------
bl_len_ns
The baseline length in nanosec (i.e. 1e9 * metres / c). If scalar, interpreted
as E-W length, if len(2), interpreted as EW and NS length, otherwise the full
[EW, NS, Z] length. Unspecified dimensions are assumed to be zero.
Returns
-------
mag
The magnitude of the baseline length.
"""
bl_len_ns = _get_bl_len_vec(bl_len_ns)
return np.sqrt(np.sum(bl_len_ns ** 2))
def gen_delay_filter(
freqs: np.ndarray,
bl_len_ns: Union[float, np.ndarray, Sequence],
standoff: float = 0.0,
delay_filter_type: Optional[str] = "gauss",
min_delay: Optional[float] = None,
max_delay: Optional[float] = None,
normalize: Optional[float] = None,
) -> np.ndarray:
"""
Generate a delay filter in delay space.
Parameters
----------
freqs
Frequency array [GHz]
bl_len_ns
The baseline length in nanosec (i.e. 1e9 * metres / c). If scalar, interpreted
as E-W length, if len(2), interpreted as EW and NS length, otherwise the full
[EW, NS, Z] length. Unspecified dimensions are assumed to be zero.
standoff
Supra-horizon buffer [nanosec]
delay_filter_type
Options are ``['gauss', 'trunc_gauss', 'tophat', 'none']``.
This sets the filter profile. ``gauss`` has a 1-sigma as horizon (+ standoff)
divided by four, ``trunc_gauss`` is same but truncated above 1-sigma. ``'none'``
means filter is identically one.
min_delay
Minimum absolute delay of filter
max_delay
Maximum absolute delay of filter
normalize
If set, will normalize the filter such that the power of the output
matches the power of the input times the normalization factor.
If not set, the filter merely has a maximum of unity.
Returns
-------
delay_filter
Delay filter in delay space (1D)
"""
# setup
delays = np.fft.fftfreq(freqs.size, freqs[1] - freqs[0])
if isinstance(bl_len_ns, np.ndarray):
bl_len_ns = np.linalg.norm(bl_len_ns)
# add standoff: four sigma is horizon
one_sigma = (bl_len_ns + standoff) / 4.0
# create filter
if delay_filter_type in [None, "none", "None"]:
delay_filter = | np.ones_like(delays) | numpy.ones_like |
"""
fitting.py
Created by <NAME> on 2017-05-19.
"""
import os
import glob
import inspect
from collections import OrderedDict
import numpy as np
import astropy.io.fits as pyfits
import astropy.units as u
from astropy.cosmology import Planck15
import astropy.constants as const
from . import utils
#from .model import BeamCutout
from .utils import GRISM_COLORS
# Minimum redshift where IGM is applied
IGM_MINZ = 3.4 # blue edge of G800L
# Default parameters for drizzled line map
PLINE = {'kernel': 'point', 'pixfrac': 0.2, 'pixscale': 0.1, 'size': 8, 'wcs': None}
# IGM from eazy-py
try:
import eazy.igm
IGM = eazy.igm.Inoue14()
except:
IGM = None
def run_all_parallel(id, get_output_data=False, **kwargs):
import numpy as np
from grizli.fitting import run_all
from grizli import multifit
import time
import traceback
t0 = time.time()
print('Run {0}'.format(id))
args = np.load('fit_args.npy')[0]
args['verbose'] = False
for k in kwargs:
args[k] = kwargs[k]
fp = open('{0}_{1:05d}.log_par'.format(args['group_name'], id),'w')
fp.write('{0}_{1:05d}: {2}\n'.format(args['group_name'], id, time.ctime()))
fp.close()
try:
#args['zr'] = [0.7, 1.0]
#mb = multifit.MultiBeam('j100025+021651_{0:05d}.beams.fits'.format(id))
out = run_all(id, **args)
if get_output_data:
return out
status=1
except:
status=-1
trace = traceback.format_exc(limit=2)#, file=fp)
if args['verbose']:
print(trace)
t1 = time.time()
return id, status, t1-t0
def run_all(id, t0=None, t1=None, fwhm=1200, zr=[0.65, 1.6], dz=[0.004, 0.0002], fitter='nnls', group_name='grism', fit_stacks=True, only_stacks=False, prior=None, fcontam=0.2, pline=PLINE, mask_sn_limit=3, fit_only_beams=False, fit_beams=True, root='*', fit_trace_shift=False, phot=None, phot_obj=None, verbose=True, scale_photometry=False, show_beams=True, scale_on_stacked_1d=True, overlap_threshold=5, MW_EBV=0., sys_err=0.03, get_dict=False, bad_pa_threshold=1.6, units1d='flam', redshift_only=False, line_size=1.6, use_psf=False, get_line_width=False, sed_args={'bin':1, 'xlim':[0.3, 9]}, get_ir_psfs=True, min_mask=0.01, min_sens=0.08, **kwargs):
"""Run the full procedure
1) Load MultiBeam and stack files
2) ... tbd
fwhm=1200; zr=[0.65, 1.6]; dz=[0.004, 0.0002]; group_name='grism'; fit_stacks=True; prior=None; fcontam=0.2; mask_sn_limit=3; fit_beams=True; root=''
"""
import glob
import grizli.multifit
from grizli.stack import StackFitter
from grizli.multifit import MultiBeam
if get_dict:
frame = inspect.currentframe()
args = inspect.getargvalues(frame).locals
for k in ['id', 'get_dict', 'frame', 'glob', 'grizli', 'StackFitter', 'MultiBeam']:
if k in args:
args.pop(k)
return args
mb_files = glob.glob('{0}_{1:05d}.beams.fits'.format(root, id))
st_files = glob.glob('{0}_{1:05d}.stack.fits'.format(root, id))
if not only_stacks:
mb = MultiBeam(mb_files, fcontam=fcontam, group_name=group_name, MW_EBV=MW_EBV, sys_err=sys_err, verbose=verbose, psf=use_psf, min_mask=min_mask, min_sens=min_sens)
# Check for PAs with unflagged contamination or otherwise discrepant
# fit
out = mb.check_for_bad_PAs(chi2_threshold=bad_pa_threshold,
poly_order=1, reinit=True,
fit_background=True)
fit_log, keep_dict, has_bad = out
if has_bad:
if verbose:
print('\nHas bad PA! Final list: {0}\n{1}'.format(keep_dict,
fit_log))
hdu, fig = mb.drizzle_grisms_and_PAs(fcontam=0.5, flambda=False, kernel='point', size=32)
fig.savefig('{0}_{1:05d}.fix.stack.png'.format(group_name, id))
good_PAs = []
for k in keep_dict:
good_PAs.extend(keep_dict[k])
else:
good_PAs = None # All good
else:
good_PAs = None # All good
redshift_only=True # can't drizzle line maps from stacks
if fit_only_beams:
st = None
else:
st = StackFitter(st_files, fit_stacks=fit_stacks, group_name=group_name, fcontam=fcontam, overlap_threshold=overlap_threshold, MW_EBV=MW_EBV, verbose=verbose, sys_err=sys_err, PAs=good_PAs, chi2_threshold=bad_pa_threshold)
st.initialize_masked_arrays()
if only_stacks:
mb = st
if not only_stacks:
if fit_trace_shift:
b = mb.beams[0]
b.compute_model()
sn_lim = fit_trace_shift*1
if (np.max((b.model/b.grism['ERR'])[b.fit_mask.reshape(b.sh)]) > sn_lim) | (sn_lim > 100):
shift, _ = mb.fit_trace_shift(tol=1.e-3, verbose=verbose,
split_groups=True)
mb.initialize_masked_arrays()
## Get photometry from phot_obj
if (phot is None) & (phot_obj is not None):
phot_i, ii, dd = phot_obj.get_phot_dict(mb.ra, mb.dec)
if dd < 0.5*u.arcsec:
phot = phot_i
if phot is not None:
if phot == 'vizier':
### Get photometry from Vizier catalogs
vizier_catalog = list(utils.VIZIER_BANDS.keys())
phot = utils.get_Vizier_photometry(mb.ra, mb.dec, verbose=verbose,
vizier_catalog=vizier_catalog)
if phot is not None:
zgrid = utils.log_zgrid(zr=zr, dz=0.005)
phot['tempfilt'] = utils.generate_tempfilt(t0,
phot['filters'],
zgrid=zgrid,
MW_EBV=MW_EBV)
if phot is not None:
if st is not None:
st.set_photometry(**phot, min_err=sys_err)
mb.set_photometry(**phot, min_err=sys_err)
if t0 is None:
t0 = utils.load_templates(line_complexes=True, fsps_templates=True, fwhm=fwhm)
if t1 is None:
t1 = utils.load_templates(line_complexes=False, fsps_templates=True, fwhm=fwhm)
# Fit on stacked spectra or individual beams
if fit_only_beams:
fit_obj = mb
else:
fit_obj = st
### Do scaling now with direct spectrum function
if (scale_photometry > 0) & (phot is not None):
try:
scl = mb.scale_to_photometry(z=0, method='lm', templates=t0, order=scale_photometry*1-1)
except:
scl = [10.]
if hasattr(scl,'status'):
if scl.status > 0:
print('scale_to_photometry: [{0}]'.format(', '.join(['{0:.2f}'.format(x_i) for x_i in scl.x])))
mb.pscale = scl.x
if st is not None:
st.pscale = scl.x
# First pass
fit = fit_obj.xfit_redshift(templates=t0, zr=zr, dz=dz, prior=prior, fitter=fitter, verbose=verbose)
fit_hdu = pyfits.table_to_hdu(fit)
fit_hdu.header['EXTNAME'] = 'ZFIT_STACK'
if hasattr(fit_obj, 'pscale'):
fit_hdu.header['PSCALEN'] = (len(fit_obj.pscale)-1, 'PSCALE order')
for i, p in enumerate(fit_obj.pscale):
fit_hdu.header['PSCALE{0}'.format(i)] = (p, 'PSCALE parameter {0}'.format(i))
# Add photometry information
if (fit_obj.Nphot > 0) & hasattr(fit_obj, 'photom_filters'):
h = fit_hdu.header
h['NPHOT'] = fit_obj.Nphot, 'Number of photometry filters'
h['PHOTSRC'] = fit_obj.photom_source, 'Source of the photometry'
for i in range(len(fit_obj.photom_filters)):
h['PHOTN{0:03d}'.format(i)] = fit_obj.photom_filters[i].name.split()[0], 'Filter {0} name'.format(i)
h['PHOTL{0:03d}'.format(i)] = fit_obj.photom_pivot[i], 'Filter {0} pivot wavelength'.format(i)
h['PHOTF{0:03d}'.format(i)] = fit_obj.photom_flam[i], 'Filter {0} flux flam'.format(i)
h['PHOTE{0:03d}'.format(i)] = fit_obj.photom_eflam[i], 'Filter {0} err flam'.format(i)
# # Second pass if rescaling spectrum to photometry
# if scale_photometry:
# scl = mb.scale_to_photometry(z=fit.meta['z_map'][0], method='lm', templates=t0, order=scale_photometry*1-1)
# if scl.status > 0:
# mb.pscale = scl.x
# if st is not None:
# st.pscale = scl.x
#
# fit = fit_obj.xfit_redshift(templates=t0, zr=zr, dz=dz, prior=prior, fitter=fitter, verbose=verbose)
# fit_hdu = pyfits.table_to_hdu(fit)
# fit_hdu.header['EXTNAME'] = 'ZFIT_STACK'
# Zoom-in fit with individual beams
if fit_beams:
#z0 = fit.meta['Z50'][0]
z0 = fit.meta['z_map'][0]
#width = np.maximum(3*fit.meta['ZWIDTH1'][0], 3*0.001*(1+z0))
width = 20*0.001*(1+z0)
mb_zr = z0 + width*np.array([-1,1])
mb_fit = mb.xfit_redshift(templates=t0, zr=mb_zr, dz=[0.001, 0.0002], prior=prior, fitter=fitter, verbose=verbose)
mb_fit_hdu = pyfits.table_to_hdu(mb_fit)
mb_fit_hdu.header['EXTNAME'] = 'ZFIT_BEAM'
else:
mb_fit = fit
#### Get best-fit template
tfit = mb.template_at_z(z=mb_fit.meta['z_map'][0], templates=t1, fit_background=True, fitter=fitter)
# Redrizzle? ... testing
if False:
hdu, fig = mb.drizzle_grisms_and_PAs(fcontam=fcontam,
flambda=False,
size=48, scale=1.,
kernel='point', pixfrac=0.1,
zfit=tfit)
# Fit covariance
cov_hdu = pyfits.ImageHDU(data=tfit['covar'], name='COVAR')
Next = mb_fit.meta['N']
cov_hdu.header['N'] = Next
# Line EWs & fluxes
coeffs_clip = tfit['coeffs'][mb.N:]
covar_clip = tfit['covar'][mb.N:,mb.N:]
lineEW = utils.compute_equivalent_widths(t1, coeffs_clip, covar_clip, max_R=5000, Ndraw=1000, z=tfit['z'])
for ik, key in enumerate(lineEW):
for j in range(3):
if not np.isfinite(lineEW[key][j]):
lineEW[key][j] = -1.e30
cov_hdu.header['FLUX_{0:03d}'.format(ik)] = tfit['cfit'][key][0], '{0} line flux; erg / (s cm2)'.format(key.strip('line '))
cov_hdu.header['ERR_{0:03d}'.format(ik)] = tfit['cfit'][key][1], '{0} line uncertainty; erg / (s cm2)'.format(key.strip('line '))
cov_hdu.header['EW16_{0:03d}'.format(ik)] = lineEW[key][0], 'Rest-frame {0} EW, 16th percentile; Angstrom'.format(key.strip('line '))
cov_hdu.header['EW50_{0:03d}'.format(ik)] = lineEW[key][1], 'Rest-frame {0} EW, 50th percentile; Angstrom'.format(key.strip('line '))
cov_hdu.header['EW84_{0:03d}'.format(ik)] = lineEW[key][2], 'Rest-frame {0} EW, 84th percentile; Angstrom'.format(key.strip('line '))
cov_hdu.header['EWHW_{0:03d}'.format(ik)] = (lineEW[key][2]-lineEW[key][0])/2, 'Rest-frame {0} EW, 1-sigma half-width; Angstrom'.format(key.strip('line '))
# Velocity width
if get_line_width:
if phot is not None:
mb.unset_photometry()
vel_width_res = mb.fit_line_width(z0=tfit['z'], bl=1.2, nl=1.2)
if verbose:
print('Velocity width: BL/NL = {0:.0f}/{1:.0f}, z={2:.4f}'.format(vel_width_res[0]*1000, vel_width_res[1]*1000, vel_width_res[2]))
fit_hdu.header['VEL_BL'] = vel_width_res[0]*1000, 'Broad line FWHM'
fit_hdu.header['VEL_NL'] = vel_width_res[1]*1000, 'Narrow line FWHM'
fit_hdu.header['VEL_Z'] = vel_width_res[2], 'Line width, best redshift'
fit_hdu.header['VEL_NFEV'] = vel_width_res[3], 'Line width, NFEV'
fit_hdu.header['VEL_FLAG'] = vel_width_res[4], 'Line width, NFEV'
if phot is not None:
mb.set_photometry(**phot)
# Best-fit template itself
tfit_sp = utils.GTable()
for ik, key in enumerate(tfit['cfit']):
for save in [tfit_sp.meta]:
save['CVAL{0:03d}'.format(ik)] = tfit['cfit'][key][0], 'Coefficient for {0}'.format(key)
save['CERR{0:03d}'.format(ik)] = tfit['cfit'][key][1], 'Uncertainty for {0}'.format(key)
save['CNAME{0:03d}'.format(ik)] = key, 'Template name'
tfit_sp['wave'] = tfit['cont1d'].wave
tfit_sp['continuum'] = tfit['cont1d'].flux
tfit_sp['full'] = tfit['line1d'].flux
tfit_sp['wave'].unit = tfit['cont1d'].waveunits
tfit_sp['continuum'].unit = tfit['cont1d'].fluxunits
tfit_sp['full'].unit = tfit['line1d'].fluxunits
tfit_hdu = pyfits.table_to_hdu(tfit_sp)
tfit_hdu.header['EXTNAME'] = 'TEMPL'
# Make the plot
fig = mb.xmake_fit_plot(mb_fit, tfit, show_beams=show_beams, scale_on_stacked_1d=scale_on_stacked_1d)
# Add prior
if prior is not None:
fig.axes[0].plot(prior[0], np.log10(prior[1]), color='#1f77b4', alpha=0.5)
# Add stack fit to the existing plot
fig.axes[0].plot(fit['zgrid'], np.log10(fit['pdf']), color='0.5', alpha=0.5)
fig.axes[0].set_xlim(fit['zgrid'].min(), fit['zgrid'].max())
if phot is not None:
fig.axes[1].errorbar(mb.photom_pivot/1.e4, mb.photom_flam/1.e-19, mb.photom_eflam/1.e-19, marker='s', alpha=0.5, color='k', linestyle='None')
#fig.axes[1].plot(tfit['line1d'].wave/1.e4, tfit['line1d'].flux/1.e-19, color='k', alpha=0.2, zorder=100)
# Save the figure
fig.savefig('{0}_{1:05d}.full.png'.format(group_name, id))
if redshift_only:
return mb, st, fit, tfit, None
# Make the line maps
if pline is None:
pzfit, pspec2, pline = grizli.multifit.get_redshift_fit_defaults()
line_hdu = mb.drizzle_fit_lines(tfit, pline, force_line=utils.DEFAULT_LINE_LIST, save_fits=False, mask_lines=True, mask_sn_limit=mask_sn_limit, verbose=verbose, get_ir_psfs=get_ir_psfs)
# Add beam exposure times
exptime = mb.compute_exptime()
for k in exptime:
line_hdu[0].header['T_{0}'.format(k)] = (exptime[k], 'Total exposure time [s]')
line_hdu.insert(1, fit_hdu)
line_hdu.insert(2, cov_hdu)
if fit_beams:
line_hdu.insert(2, mb_fit_hdu)
line_hdu.insert(3, tfit_hdu)
line_hdu.writeto('{0}_{1:05d}.full.fits'.format(group_name, id), clobber=True, output_verify='fix')
# 1D spectrum
oned_hdul = mb.oned_spectrum_to_hdu(tfit=tfit, bin=1, outputfile='{0}_{1:05d}.1D.fits'.format(group_name, id))#, units=units1d)
######
# Show the drizzled lines and direct image cutout, which are
# extensions `DSCI`, `LINE`, etc.
s, si = 1, line_size
s = 4.e-19/np.max([beam.beam.total_flux for beam in mb.beams])
s = np.clip(s, 0.25, 4)
full_line_list = ['Lya', 'OII', 'Hb', 'OIII', 'Ha', 'SII', 'SIII']
fig = show_drizzled_lines(line_hdu, size_arcsec=si, cmap='plasma_r', scale=s, dscale=s, full_line_list=full_line_list)
fig.savefig('{0}_{1:05d}.line.png'.format(group_name, id))
if phot is not None:
out = mb, st, fit, tfit, line_hdu
if 'pz' in phot:
full_sed_plot(mb, tfit, zfit=fit, photometry_pz=phot['pz'], **sed_args)
else:
full_sed_plot(mb, tfit, zfit=fit, **sed_args)
return mb, st, fit, tfit, line_hdu
###################################
def full_sed_plot(mb, tfit, zfit=None, bin=1, minor=0.1, save='png', sed_resolution=180, photometry_pz=None, zspec=None, spectrum_steps=False, xlim=[0.3, 9], **kwargs):
"""
Make a separate plot showing photometry and the spectrum
"""
#import seaborn as sns
import prospect.utils.smoothing
import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator
import matplotlib.gridspec as gridspec
#mpl_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
mpl_colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
# sns_colors = colors = sns.color_palette("cubehelix", 8)
### seaborn cubehelix colors
sns_colors = colors = [(0.1036, 0.094, 0.206),
(0.0825, 0.272, 0.307),
(0.1700, 0.436, 0.223),
(0.4587, 0.480, 0.199),
(0.7576, 0.476, 0.437),
(0.8299, 0.563, 0.776),
(0.7638, 0.757, 0.949),
(0.8106, 0.921, 0.937)]
# Best-fit
#mb = out[0]
#zfit = out[2]
#tfit = out[3]
t1 = tfit['templates']
best_model = mb.get_flat_model([tfit['line1d'].wave, tfit['line1d'].flux])
flat_model = mb.get_flat_model([tfit['line1d'].wave, tfit['line1d'].flux*0+1])
bg = mb.get_flat_background(tfit['coeffs'])
sp = mb.optimal_extract(mb.scif[mb.fit_mask][:-mb.Nphot] - bg, bin=bin)#['G141']
spm = mb.optimal_extract(best_model, bin=bin)#['G141']
spf = mb.optimal_extract(flat_model, bin=bin)#['G141']
# Photometry
A_phot = mb._interpolate_photometry(z=tfit['z'], templates=t1)
A_model = A_phot.T.dot(tfit['coeffs'])
photom_mask = mb.photom_eflam > -98
##########
# Figure
if True:
if zfit is not None:
fig = plt.figure(figsize=[11, 9./3])
gs = gridspec.GridSpec(1,3, width_ratios=[1,1.5,1])
ax1 = fig.add_subplot(gs[0])
ax2 = fig.add_subplot(gs[1])
ax3 = fig.add_subplot(gs[2])
else:
fig = plt.figure(figsize=[9, 9./3])
gs = gridspec.GridSpec(1,2, width_ratios=[1,1.5])
ax1 = fig.add_subplot(gs[0])
ax2 = fig.add_subplot(gs[1])
else:
gs = None
fig = plt.figure(figsize=[9, 9./3])
ax1 = fig.add_subplot(131)
ax2 = fig.add_subplot(132)
ax3 = fig.add_subplot(133)
# Photometry SED
ax1.errorbar(np.log10(mb.photom_pivot[photom_mask]/1.e4), mb.photom_flam[photom_mask]/1.e-19, mb.photom_eflam[photom_mask]/1.e-19, color='k', alpha=0.6, marker='s', linestyle='None', zorder=30)
sm = prospect.utils.smoothing.smoothspec(tfit['line1d'].wave, tfit['line1d'].flux, resolution=sed_resolution, smoothtype='R') #nsigma=10, inres=10)
ax1.scatter(np.log10(mb.photom_pivot[photom_mask]/1.e4), A_model/1.e-19, color='w', marker='s', s=80, zorder=10)
ax1.scatter(np.log10(mb.photom_pivot[photom_mask]/1.e4), A_model/1.e-19, color=sns_colors[4], marker='s', s=20, zorder=11)
yl1 = ax1.get_ylim()
ax1.plot(np.log10(tfit['line1d'].wave/1.e4), sm/1.e-19, color=sns_colors[4], linewidth=1, zorder=0)
#ax1.grid()
ax1.set_xlabel(r'$\lambda$ / $\mu$m')
ax2.set_xlabel(r'$\lambda$ / $\mu$m')
# Spectrum
ymax, ymin = -1e30, 1e30
for g in sp:
sn = sp[g]['flux']/sp[g]['err']
clip = sn > 3
clip = spf[g]['flux'] > 0.2*spf[g]['flux'].max()
try:
scale = mb.compute_scale_array(mb.pscale, sp[g]['wave'])
except:
scale = 1
ax2.errorbar(sp[g]['wave'][clip]/1.e4, (sp[g]['flux']/spf[g]['flux']/scale)[clip]/1.e-19, (sp[g]['err']/spf[g]['flux']/scale)[clip]/1.e-19, marker='.', color='k', alpha=0.5, linestyle='None', elinewidth=0.5, zorder=11)
if spectrum_steps:
ax2.plot(sp[g]['wave']/1.e4, spm[g]['flux']/spf[g]['flux']/1.e-19, color=sns_colors[4], linewidth=2, alpha=0.8, zorder=10, linestyle='steps-mid')
else:
ax2.plot(sp[g]['wave']/1.e4, spm[g]['flux']/spf[g]['flux']/1.e-19, color=sns_colors[4], linewidth=2, alpha=0.8, zorder=10, marker='.')
ymax = np.maximum(ymax, (spm[g]['flux']/spf[g]['flux']/1.e-19)[clip].max())
ymin = np.minimum(ymin, (spm[g]['flux']/spf[g]['flux']/1.e-19)[clip].min())
ax1.errorbar(np.log10(sp[g]['wave'][clip]/1.e4), (sp[g]['flux']/spf[g]['flux']/scale)[clip]/1.e-19, (sp[g]['err']/spf[g]['flux']/scale)[clip]/1.e-19, marker='.', color='k', alpha=0.2, linestyle='None', elinewidth=0.5, zorder=-100)
xl, yl = ax2.get_xlim(), ax2.get_ylim()
yl = (ymin-0.3*ymax, 1.3*ymax)
# SED x range
if xlim is None:
okphot = (mb.photom_eflam > 0)
xlim = [np.minimum(xl[0]*0.7, 0.7*mb.photom_pivot[okphot].min()/1.e4), np.maximum(xl[1]/0.7, mb.photom_pivot[okphot].max()/1.e4/0.7)]
ax1.set_xlim(np.log10(xlim[0]), np.log10(xlim[1]))
ticks = np.array([0.5, 1, 2, 4, 8])
ticks = ticks[(ticks >= xlim[0]) & (ticks <= xlim[1])]
ax1.set_xticks(np.log10(ticks))
ax1.set_xticklabels(ticks)
# Back to spectrum
ax2.scatter((mb.photom_pivot[photom_mask]/1.e4), A_model/1.e-19, color='w', marker='s', s=80, zorder=11)
ax2.scatter((mb.photom_pivot[photom_mask]/1.e4), A_model/1.e-19, color=sns_colors[4], marker='s', s=20, zorder=12)
ax2.errorbar(mb.photom_pivot[photom_mask]/1.e4, mb.photom_flam[photom_mask]/1.e-19, mb.photom_eflam[photom_mask]/1.e-19, color='k', alpha=0.6, marker='s', linestyle='None', zorder=20)
ax2.set_xlim(xl); ax2.set_ylim(yl)
ax2.set_yticklabels([])
#ax2.set_xticks(np.arange(1.1, 1.8, 0.1))
#ax2.set_xticklabels([1.1, '', 1.3, '', 1.5, '', 1.7])
ax2.xaxis.set_minor_locator(MultipleLocator(minor))
ax2.xaxis.set_major_locator(MultipleLocator(minor*2))
# Show spectrum range on SED panel
xb, yb = np.array([0, 1, 1, 0, 0]), np.array([0, 0, 1, 1, 0])
ax1.plot(np.log10(xl[0]+xb*(xl[1]-xl[0])), yl[0]+yb*(yl[1]-yl[0]), linestyle=':', color='k', alpha=0.4)
ymax = np.maximum(yl1[1], yl[1]+0.02*(yl[1]-yl[0]))
ax1.set_ylim(-0.1*ymax, ymax)
tick_diff = np.diff(ax1.get_yticks())[0]
ax2.yaxis.set_major_locator(MultipleLocator(tick_diff))
#ax2.set_yticklabels([])
##########
# P(z)
if zfit is not None:
if photometry_pz is not None:
ax3.plot(photometry_pz[0], np.log10(photometry_pz[1]), color=mpl_colors[0])
ax3.plot(zfit['zgrid'], np.log10(zfit['pdf']), color=sns_colors[0])
ax3.fill_between(zfit['zgrid'], np.log10(zfit['pdf']), np.log10(zfit['pdf'])*0-100, color=sns_colors[0], alpha=0.3)
ax3.set_xlim(zfit['zgrid'].min(), zfit['zgrid'].max())
ax3.set_ylim(-3, 2.9) #np.log10(zfit['pdf']).max())
ax3.set_ylabel(r'log $p(z)$')
ax3.set_xlabel(r'$z$')
ax1.set_ylabel(r'$f_\lambda$ / $10^{-19}$')
axt = ax2
axt.text(0.95, 0.95, r'$z_\mathrm{grism}$='+'{0:.3f}'.format(tfit['z']), ha='right', va='top', transform=axt.transAxes, color=sns_colors[0], size=10)#, backgroundcolor='w')
if zspec is not None:
axt.text(0.95, 0.89, r'$z_\mathrm{spec}$='+'{0:.3f}'.format(zspec), ha='right', va='top', transform=axt.transAxes, color='r', size=10)
if zfit is not None:
ax3.scatter(zspec, 2.7, color='r', marker='v', zorder=100)
axt.text(0.05, 0.95, '{0}: {1:>6d}'.format(mb.group_name, mb.id), ha='left', va='top', transform=axt.transAxes, color='k', size=10)#, backgroundcolor='w')
#axt.text(0.05, 0.89, '{0:>6d}'.format(mb.id), ha='left', va='top', transform=axt.transAxes, color='k', size=10)#, backgroundcolor='w')
if gs is None:
gs.tight_layout(pad=0.1)
else:
if zfit is not None:
fig.tight_layout(pad=0.1)
else:
fig.tight_layout(pad=0.5)
if save:
fig.savefig('{0}_{1:05d}.sed.{2}'.format(mb.group_name, mb.id, save))
return fig
def make_summary_catalog(target='pg0117+213', sextractor='pg0117+213-f140w.cat', verbose=True, filter_bandpasses=[]):
import glob
import os
from collections import OrderedDict
import matplotlib.pyplot as plt
import astropy.units as u
import astropy.io.fits as pyfits
import numpy as np
import grizli
from grizli import utils
keys = OrderedDict()
keys['PRIMARY'] = ['ID','RA','DEC','NINPUT','REDSHIFT','T_G102', 'T_G141', 'T_G800L', 'NUMLINES','HASLINES']
keys['ZFIT_STACK'] = ['CHI2POLY','CHI2SPL','SPLF01','SPLE01','SPLF02','SPLE02','SPLF03','SPLE03','SPLF04','SPLE04', 'DOF','CHIMIN','CHIMAX','BIC_POLY','BIC_SPL','BIC_TEMP','Z02', 'Z16', 'Z50', 'Z84', 'Z97', 'ZWIDTH1', 'ZWIDTH2', 'Z_MAP', 'Z_RISK', 'MIN_RISK', 'VEL_BL','VEL_NL','VEL_Z','VEL_NFEV','VEL_FLAG']
keys['ZFIT_BEAM'] = ['CHI2POLY','CHI2SPL','SPLF01','SPLE01','SPLF02','SPLE02','SPLF03','SPLE03','SPLF04','SPLE04', 'DOF','CHIMIN','CHIMAX','BIC_POLY','BIC_SPL','BIC_TEMP','Z02', 'Z16', 'Z50', 'Z84', 'Z97', 'ZWIDTH1', 'ZWIDTH2', 'Z_MAP', 'Z_RISK', 'MIN_RISK', 'VEL_BL','VEL_NL','VEL_Z','VEL_NFEV','VEL_FLAG']
keys['COVAR'] = ' '.join(['FLUX_{0:03d} ERR_{0:03d} EW50_{0:03d} EWHW_{0:03d}'.format(i) for i in range(24)]).split()
lines = []
pdf_max = []
files=glob.glob('{0}*full.fits'.format(target))
files.sort()
template_mags = []
sps_params = []
for file in files:
print(utils.NO_NEWLINE+file)
line = []
full = pyfits.open(file)
if 'DSCI' not in full:
continue
tab = utils.GTable.read(full['ZFIT_STACK'])
pdf_max.append(tab['pdf'].max())
for ext in keys:
if ext not in full:
for k in keys[ext]:
line.append(np.nan)
continue
h = full[ext].header
for k in keys[ext]:
if k in h:
line.append(h[k])
else:
line.append(np.nan)
# SPS
try:
sps = compute_sps_params(full)
except:
sps = {'Lv':-1*u.solLum, 'MLv':-1*u.solMass/u.solLum, 'MLv_rms':-1*u.solMass/u.solLum, 'SFRv':-1*u.solMass/u.year, 'SFRv_rms':-1*u.solMass/u.year, 'templ':-1}
sps_params.append(sps)
lines.append(line)
# Integrate best-fit template through filter bandpasses
if filter_bandpasses:
tfit = utils.GTable.gread(full['TEMPL'])
sp = utils.SpectrumTemplate(wave=tfit['wave'], flux=tfit['full'])
mags = [sp.integrate_filter(bp, abmag=True)
for bp in filter_bandpasses]
template_mags.append(mags)
columns = []
for ext in keys:
if ext == 'ZFIT_BEAM':
columns.extend(['beam_{0}'.format(k) for k in keys[ext]])
else:
columns.extend(keys[ext])
info = utils.GTable(rows=lines, names=columns)
info['PDF_MAX'] = pdf_max
root_col = utils.GTable.Column(name='root', data=[target]*len(info))
info.add_column(root_col, index=0)
for k in ['Lv','MLv','MLv_rms','SFRv','SFRv_rms']:
datak = [sps[k].value for sps in sps_params]
info[k] = datak
info[k].unit = sps[k].unit
info['sSFR'] = info['SFRv']/info['MLv']
info['stellar_mass'] = info['Lv']*info['MLv']
info['Lv'].format = '.1e'
info['MLv'].format = '.2f'
info['MLv_rms'].format = '.2f'
info['SFRv'].format = '.1f'
info['SFRv_rms'].format = '.1f'
info['sSFR'].format = '.1e'
info['stellar_mass'].format = '.1e'
if filter_bandpasses:
arr = np.array(template_mags)
for i, bp in enumerate(filter_bandpasses):
info['mag_{0}'.format(bp.name)] = arr[:,i]
info['mag_{0}'.format(bp.name)].format = '.3f'
for c in info.colnames:
info.rename_column(c, c.lower())
# Emission line names
files=glob.glob('{0}*full.fits'.format(target))
im = pyfits.open(files[0])
h = im['COVAR'].header
for i in range(24):
key = 'FLUX_{0:03d}'.format(i)
if key not in h:
continue
line = h.comments[key].split()[0]
for root in ['flux','err','ew50','ewhw']:
col = '{0}_{1}'.format(root, line)
info.rename_column('{0}_{1:03d}'.format(root, i), col)
if root.startswith('ew'):
info[col].format = '.1f'
else:
info[col].format = '.1f'
info['sn_{0}'.format(line)] = info['flux_'+line]/info['err_'+line]
info['sn_{0}'.format(line)][info['err_'+line] == 0] = -99
#info['sn_{0}'.format(line)].format = '.1f'
info['chinu'] = info['chimin']/info['dof']
info['chinu'].format = '.2f'
info['bic_diff'] = info['bic_poly'] - info['bic_temp']
info['bic_diff'].format = '.1f'
info['log_risk'] = np.log10(info['min_risk'])
info['log_risk'].format = '.2f'
info['log_pdf_max'] = np.log10(info['pdf_max'])
info['log_pdf_max'].format = '.2f'
info['zq'] = info['log_risk'] - info['log_pdf_max']
info['zq'].format = '.2f'
info['beam_chinu'] = info['beam_chimin']/info['beam_dof']
info['beam_chinu'].format = '.2f'
info['beam_bic_diff'] = info['beam_bic_poly'] - info['beam_bic_temp']
info['beam_bic_diff'].format = '.1f'
info['beam_log_risk'] = np.log10(info['beam_min_risk'])
info['beam_log_risk'].format = '.2f'
# ID with link to CDS
idx = ['<a href="http://vizier.u-strasbg.fr/viz-bin/VizieR?-c={0:.6f}+{1:.6f}&-c.rs=2">{2}</a>'.format(info['ra'][i], info['dec'][i], info['id'][i]) for i in range(len(info))]
info['idx'] = idx
### PNG columns
for ext in ['stack','full','line']:
png = ['{0}_{1:05d}.{2}.png'.format(target, id, ext) for id in info['id']]
info['png_{0}'.format(ext)] = ['<a href={0}><img src={0} height=200></a>'.format(p) for p in png]
### Column formats
for col in info.colnames:
if col.strip('beam_').startswith('z'):
info[col].format = '.4f'
if col in ['ra','dec']:
info[col].format = '.6f'
### Sextractor catalog
if sextractor is None:
info.write('{0}.info.fits'.format(target), overwrite=True)
return info
#sextractor = glob.glob('{0}-f*cat'.format(target))[0]
try:
hcat = grizli.utils.GTable.gread(sextractor) #, format='ascii.sextractor')
except:
hcat = grizli.utils.GTable.gread(sextractor, sextractor=True)
for c in hcat.colnames:
hcat.rename_column(c, c.lower())
idx, dr = hcat.match_to_catalog_sky(info, self_radec=('x_world', 'y_world'), other_radec=None)
for c in hcat.colnames:
info.add_column(hcat[c][idx])
info.write('{0}.info.fits'.format(target), overwrite=True)
return info
def compute_sps_params(full='j021820-051015_01276.full.fits', cosmology=Planck15):
import numpy as np
from astropy.io import fits as pyfits
from astropy.table import Table
import astropy.units as u
from grizli import utils
import pysynphot as S
if isinstance(full, str):
im = pyfits.open(full)
else:
im = full
h = im['TEMPL'].header
templ = Table(im['TEMPL'].data)
z = im['ZFIT_STACK'].header['Z_MAP']
# Get coefffs
coeffs, keys, ix = [], [], []
count=0
for k in h:
if k.startswith('CNAME'):
if h[k].startswith('fsps'):
ix.append(count)
keys.append(h[k])
coeffs.append(h[k.replace('CNAME','CVAL')])
count += 1
cov = im['COVAR'].data[np.array(ix),:][:,np.array(ix)]
covd = cov.diagonal()
# Normalize to V band, fsps_QSF_12_v3
normV = np.array([3.75473763e-15, 2.73797790e-15, 1.89469588e-15,
1.32683449e-15, 9.16760812e-16, 2.43922395e-16, 4.76835746e-15,
3.55616962e-15, 2.43745972e-15, 1.61394625e-15, 1.05358710e-15,
5.23733297e-16])
coeffsV = np.array(coeffs)*normV
rmsV = np.sqrt(covd)*normV
rms_norm = rmsV/coeffsV.sum()
coeffs_norm = coeffsV/coeffsV.sum()
param_file = os.path.join(os.path.dirname(__file__), 'data/templates/fsps/fsps_QSF_12_v3.param.fits')
tab_temp = Table.read(param_file)
temp_MLv = tab_temp['mass']/tab_temp['Lv']
temp_SFRv = tab_temp['sfr']
mass_norm = (coeffs_norm*tab_temp['mass']).sum()*u.solMass
Lv_norm = (coeffs_norm*tab_temp['Lv']).sum()*u.solLum
MLv = mass_norm / Lv_norm
SFR_norm = (coeffs_norm*tab_temp['sfr']).sum()*u.solMass/u.yr
SFRv = SFR_norm / Lv_norm
mass_var = ((rms_norm*tab_temp['mass'])**2).sum()
Lv_var = ((rms_norm*tab_temp['Lv'])**2).sum()
SFR_var = ((rms_norm*tab_temp['sfr'])**2).sum()
MLv_var = MLv**2 * (mass_var/mass_norm.value**2 + Lv_var/Lv_norm.value**2)
MLv_rms = np.sqrt(MLv_var)
SFRv_var = SFRv**2 * (SFR_var/SFR_norm.value**2 + Lv_var/Lv_norm.value**2)
SFRv_rms = np.sqrt(SFRv_var)
vband = S.ObsBandpass('v')
vbandz = S.ArrayBandpass(vband.wave*(1+z), vband.throughput)
best_templ = utils.SpectrumTemplate(templ['wave'], templ['full'])
fnu = best_templ.integrate_filter(vbandz)*(u.erg/u.s/u.cm**2/u.Hz)
dL = cosmology.luminosity_distance(z).to(u.cm)
Lnu = fnu*4*np.pi*dL**2
pivotV = vbandz.pivot()*u.Angstrom
nuV = (const.c/pivotV).to(u.Hz)
Lv = (nuV*Lnu).to(u.L_sun)
mass = MLv*Lv
SFR = SFRv*Lv
sps = {'Lv':Lv, 'MLv':MLv, 'MLv_rms':MLv_rms, 'SFRv':SFRv, 'SFRv_rms':SFRv_rms, 'templ':best_templ}
return sps
def _loss(dz, gamma=0.15):
"""Risk / Loss function, Tanaka et al. (https://arxiv.org/abs/1704.05988)
Parameters
----------
gamma : float
Returns
-------
loss : float
"""
return 1-1/(1+(dz/gamma)**2)
def refit_beams(root='j012017+213343', append='x', id=708, keep_dict={'G141':[201, 291]}, poly_order=3, make_products=True, run_fit=True, **kwargs):
"""
Regenerate a MultiBeam object selecting only certiain PAs
Parameters
----------
root : str
Root of the "beams.fits" file to load.
append : str
String to append to the rootname of the updated products.
id : int
Object ID. The input filename is built like
>>> beams_file = '{0}_{1:05d}.beams.fits'.format(root, id)
keep_dict : bool
Dictionary of the PAs/grisms to keep. (See the
`~grizli.multifit.MultiBeam.PA` attribute.)
poly_order : int
Order of the polynomial to fit.
make_products : bool
Make stacked spectra and diagnostic figures.
run_fit : bool
Run the redshift fit on the new products
kwargs : dict
Optional keywords passed to `~grizli.fitting.run_all_parallel`.
Returns
-------
mb : `~grizli.multifit.MultiBeam`
New beam object.
"""
import numpy as np
try:
from grizli import utils, fitting
except:
from . import utils, fitting
mb = MultiBeam('{0}_{1:05d}.beams.fits'.format(root, id), group_name=root)
keep_beams = []
for g in keep_dict:
if g not in mb.PA:
continue
for pa in keep_dict[g]:
if float(pa) in mb.PA[g]:
keep_beams.extend([mb.beams[i] for i in mb.PA[g][float(pa)]])
mb = MultiBeam(keep_beams, group_name=root+append)
mb.write_master_fits()
if not make_products:
return mb
wave = np.linspace(2000,2.5e4,100)
poly_templates = utils.polynomial_templates(wave, order=poly_order)
pfit = mb.template_at_z(z=0, templates=poly_templates, fit_background=True, fitter='lstsq', get_uncertainties=2)
try:
fig1 = mb.oned_figure(figsize=[5,3], tfit=pfit)
fig1.savefig('{0}_{1:05d}.1D.png'.format(root+append, id))
except:
pass
hdu, fig = mb.drizzle_grisms_and_PAs(fcontam=0.5, flambda=False, kernel='point', size=32, zfit=pfit)
fig.savefig('{0}_{1:05d}.stack.png'.format(root+append, id))
if run_fit:
fitting.run_all_parallel(id, group_name=root+append, root=root+'x', verbose=True, **kwargs)
return mb
class GroupFitter(object):
"""Combine stack.StackFitter and MultiBeam fitting into a single object
Will have to match the attributes between the different objects, which
is already close.
"""
def _test(self):
print(self.Ngrism)
def _get_slices(self, masked=False):
"""Precompute array slices for how the individual components map into the single combined arrays.
Parameters
----------
masked : bool
Return indices of masked arrays rather than simple slices of the
full beams.
Returns
-------
slices : list
List of slices.
"""
x = 0
slices = []
# use masked index arrays rather than slices
if masked:
for i in range(self.N):
beam = self.beams[i]
if beam.fit_mask.sum() == 0:
slices.append(None)
continue
idx = np.arange(beam.fit_mask.sum())+x
slices.append(idx) #[slice(x+0, x+beam.size)][beam.fit_mask])
x = idx[-1]+1
else:
for i in range(self.N):
slices.append(slice(x+0, x+self.beams[i].size))
x += self.beams[i].size
return slices
def _update_beam_mask(self):
"""
Compute versions of the masked arrays
"""
for ib, b in enumerate(self.beams):
b.fit_mask &= self.fit_mask[self.slices[ib]]
self.mslices = self._get_slices(masked=True)
self.Nmask = self.fit_mask.sum()
if hasattr(self, 'Nphot'):
self.Nspec = self.Nmask - self.Nphot
else:
self.Nspec = self.Nmask
def _init_background(self, masked=True):
"""Initialize the (flat) background model components
Parameters
----------
None :
Returns
-------
A_bg : `~np.ndarray`
"""
if masked:
A_bg = np.zeros((self.N, self.Nmask))
for i in range(self.N):
A_bg[i, self.mslices[i]] = 1.
else:
A_bg = np.zeros((self.N, self.Ntot))
for i in range(self.N):
A_bg[i, self.slices[i]] = 1.
return A_bg
def get_SDSS_photometry(self, bands='ugriz', templ=None, radius=2, SDSS_CATALOG='V/147/sdss12', get_panstarrs=False):
#from astroquery.sdss import SDSS
#from astropy import coordinates as coords
import astropy.units as u
from astroquery.vizier import Vizier
import astropy.coordinates as coord
import pysynphot as S
from eazy.templates import Template
from eazy.filters import FilterFile
from eazy.photoz import TemplateGrid
from eazy.filters import FilterDefinition
if get_panstarrs:
SDSS_CATALOG = 'II/349'
bands = 'grizy'
# pos = coords.SkyCoord(self.ra*u.deg, self.dec*u.deg, frame='icrs')
# fields = ['ra','dec','modelMag_r', 'modelMagErr_r']
# for b in bands:
# fields.extend(['modelFlux_'+b, 'modelFluxIvar_'+b])
#
# xid = SDSS.query_region(pos, photoobj_fields=fields, spectro=False, radius=radius*u.arcsec)
from astroquery.vizier import Vizier
import astropy.units as u
import astropy.coordinates as coord
coo = coord.SkyCoord(ra=self.ra, dec=self.dec, unit=(u.deg, u.deg),
frame='icrs')
v = Vizier(catalog=SDSS_CATALOG, columns=['+_r','*'])
try:
tab = v.query_region(coo, radius="{0}s".format(radius),
catalog=SDSS_CATALOG)[0]
ix = np.argmin(tab['rmag'])
tab = tab[ix]
except:
return None
filters = [FilterDefinition(bp=S.ObsBandpass('sdss,{0}'.format(b))) for b in bands]
pivot = {}
for ib, b in enumerate(bands):
pivot[b] = filters[ib].pivot()
#to_flam = 10**(-0.4*(22.5+48.6))*3.e18 # / pivot(Ang)**2
#flam = np.array([xid['modelFlux_{0}'.format(b)][0]*to_flam/pivot[b]**2 for b in bands])
#eflam = np.array([np.sqrt(1/xid['modelFluxIvar_{0}'.format(b)][0])*to_flam/pivot[b]**2 for b in bands])
to_flam = 10**(-0.4*(48.6))*3.e18 # / pivot(Ang)**2
flam = np.array([10**(-0.4*(tab[b+'mag']))*to_flam/pivot[b]**2 for ib, b in enumerate(bands)])
eflam = np.array([tab['e_{0}mag'.format(b)]*np.log(10)/2.5*flam[ib] for ib, b in enumerate(bands)])
phot = {'flam':flam, 'eflam':eflam, 'filters':filters, 'tempfilt':None}
if templ is None:
return phot
# Make fast SDSS template grid
templates = [Template(arrays=[templ[t].wave, templ[t].flux], name=t) for t in templ]
zgrid = utils.log_zgrid(zr=[0.01, 3.4], dz=0.005)
tempfilt = TemplateGrid(zgrid, templates, filters=filters, add_igm=True, galactic_ebv=0, Eb=0, n_proc=0)
#filters = [all_filters.filters[f-1] for f in [156,157,158,159,160]]
phot = {'flam':flam, 'eflam':eflam, 'filters':filters, 'tempfilt':tempfilt}
return phot
### Vizier
def set_photometry(self, flam=[], eflam=[], filters=[], lc=None, force=False, tempfilt=None, min_err=0.02, TEF=None, pz=None, source='unknown'):
"""
Add photometry
"""
if (self.Nphot > 0) & (not force):
print('Photometry already set (Nphot={0})'.format(self.Nphot))
return True
okphot = (eflam > 0) & np.isfinite(eflam) & np.isfinite(flam)
self.Nphot = okphot.sum() #len(flam)
self.Nphotbands = len(eflam)
if self.Nphot == 0:
return True
if (len(flam) != len(eflam)) | (len(flam) != len(filters)):
print('flam/eflam/filters dimensions don\'t match')
return False
self.photom_flam = flam*1
self.photom_eflam = np.sqrt(eflam**2+(min_err*flam)**2)
self.photom_flam[~okphot] = -99
self.photom_eflam[~okphot] = -99
self.photom_filters = filters
self.photom_source = source
self.sivarf = np.hstack([self.sivarf, 1/self.photom_eflam])
self.weightf = np.hstack([self.weightf, np.ones_like(self.photom_eflam)])
self.fit_mask = np.hstack([self.fit_mask, okphot])
self.fit_mask &= self.weightf > 0
#self.flat_flam = np.hstack((self.flat_flam, self.photom_eflam*0.))
# Mask for just spectra
self.fit_mask_spec = self.fit_mask & True
self.fit_mask_spec[-self.Nphotbands:] = False
self.Nmask = self.fit_mask.sum()
self.Nspec = self.Nmask - self.Nphot
self.scif = np.hstack((self.scif, flam))
self.DoF = int((self.weightf*self.fit_mask).sum())
self.is_spec = np.isfinite(self.scif)
self.is_spec[-len(flam):] = False
self.photom_pivot = np.array([filter.pivot() for filter in filters])
self.wavef = np.hstack((self.wavef, self.photom_pivot))
# eazypy tempfilt for faster interpolation
self.tempfilt = tempfilt
self.TEF = TEF
def unset_photometry(self):
if self.Nphot == 0:
return True
Nbands = self.Nphotbands
self.sivarf = self.sivarf[:-Nbands]
self.weightf = self.weightf[:-Nbands]
#self.flat_flam = self.flat_flam[:-Nbands]
self.fit_mask = self.fit_mask[:-Nbands]
self.fit_mask &= self.weightf > 0
self.fit_mask_spec = self.fit_mask & True
self.scif = self.scif[:-Nbands]
self.wavef = self.wavef[:-Nbands]
self.DoF = int((self.weightf*self.fit_mask).sum())
self.is_spec = 1
self.Nphot = 0
self.Nphotbands = 0
self.Nmask = self.fit_mask.sum()
self.Nspec = self.Nmask - self.Nphot
self.tempfilt = None
def _interpolate_photometry(self, z=0., templates=[]):
"""
Interpolate templates through photometric filters
xx: TBD better handling of emission line templates and use eazpy tempfilt
object for huge speedup
"""
NTEMP = len(templates)
A_phot = np.zeros((NTEMP+self.N, len(self.photom_flam))) #self.Nphot))
mask = self.photom_eflam > 0
if (self.tempfilt is not None):
if (self.tempfilt.NTEMP == NTEMP):
#A_spl = self.tempfilt(z)
A_phot[self.N:,:] = self.tempfilt(z)
A_phot *= 3.e18/self.photom_pivot**2*(1+z)
A_phot[~np.isfinite(A_phot)] = 0
return A_phot[:,mask]
for it, key in enumerate(templates):
#print(key)
tz = templates[key].zscale(z, scalar=1)
for ifilt, filt in enumerate(self.photom_filters):
A_phot[self.N+it, ifilt] = tz.integrate_filter(filt)*3.e18/self.photom_pivot[ifilt]**2#*(1+z)
# pl = plt.plot(tz.wave, tz.flux)
# plt.scatter(self.photom_pivot, A_phot[self.N+it,:], color=pl[0].get_color())
return A_phot[:,mask]
def xfit_at_z(self, z=0, templates=[], fitter='nnls', fit_background=True, get_uncertainties=False, get_design_matrix=False, pscale=None, COEFF_SCALE=1.e-19, get_components=False, huber_delta=4, get_residuals=False, include_photometry=True):
"""Fit the 2D spectra with a set of templates at a specified redshift.
Parameters
----------
z : float
Redshift.
templates : list
List of templates to fit.
fitter : str
Minimization algorithm to compute template coefficients.
The default 'nnls' uses non-negative least squares.
The other option is standard 'leastsq'.
fit_background : bool
Fit additive pedestal background offset.
get_uncertainties : bool
Compute coefficient uncertainties from the covariance matrix
get_design_matrix : bool
Return design matrix and data, rather than nominal outputs.
huber_delta : float
Use the Huber loss function (`~scipy.special.huber`) rather than
direct chi-squared. If `huber_delta` < 0, then fall back to chi2.
Returns
-------
chi2 : float
Chi-squared of the fit
coeffs, coeffs_err : `~np.ndarray`
Template coefficients and uncertainties.
covariance : `~np.ndarray`
Full covariance
"""
import scipy.optimize
#import scipy.sparse
from scipy.special import huber
NTEMP = len(templates)
if (self.Nphot > 0) & include_photometry:
A = np.zeros((self.N+NTEMP, self.Nmask))
else:
A = np.zeros((self.N+NTEMP, self.Nspec))
if fit_background:
A[:self.N,:self.Nspec] = self.A_bgm
lower_bound = np.zeros(self.N+NTEMP)
lower_bound[:self.N] = -0.05
upper_bound = np.ones(self.N+NTEMP)*np.inf
upper_bound[:self.N] = 0.05
# A = scipy.sparse.csr_matrix((self.N+NTEMP, self.Ntot))
# bg_sp = scipy.sparse.csc_matrix(self.A_bg)
for i, t in enumerate(templates):
if t.startswith('line'):
lower_bound[self.N+i] = -np.inf
ti = templates[t]
if z > IGM_MINZ:
if IGM is None:
igmz = 1.
else:
lylim = ti.wave < 1250
igmz = np.ones_like(ti.wave)
igmz[lylim] = IGM.full_IGM(z, ti.wave[lylim]*(1+z))
else:
igmz = 1.
# Don't redshift spline templates
if ti.name.startswith('bspl'):
s = [ti.wave, ti.flux*igmz]
else:
s = [ti.wave*(1+z), ti.flux/(1+z)*igmz]
for j, beam in enumerate(self.beams):
mask_i = beam.fit_mask.reshape(beam.sh)
clip = mask_i.sum(axis=0) > 0
if clip.sum() == 0:
continue
lam_beam = beam.wave[clip]
if ((s[0].min() > lam_beam.max()) |
(s[0].max() < lam_beam.min())):
continue
sl = self.mslices[j]
if t in beam.thumbs:
#print('Use thumbnail!', t)
A[self.N+i, sl] = beam.compute_model(thumb=beam.thumbs[t], spectrum_1d=s, in_place=False, is_cgs=True)[beam.fit_mask]*COEFF_SCALE
else:
A[self.N+i, sl] = beam.compute_model(spectrum_1d=s, in_place=False, is_cgs=True)[beam.fit_mask]*COEFF_SCALE
# if j == 0:
# m = beam.compute_model(spectrum_1d=s, in_place=False, is_cgs=True)
# ds9.frame(i)
# ds9.view(m.reshape(beam.sh))
if fit_background:
if fitter in ['nnls', 'lstsq']:
pedestal = 0.04
else:
pedestal = 0.
else:
pedestal = 0
#oktemp = (A*self.fit_mask).sum(axis=1) != 0
oktemp = A.sum(axis=1) != 0
# Photometry
if (self.Nphot > 0):
if include_photometry:
A_phot = self._interpolate_photometry(z=z,
templates=templates)
A[:,-self.Nphot:] = A_phot*COEFF_SCALE #np.hstack((A, A_phot))
full_fit_mask = self.fit_mask
else:
full_fit_mask = self.fit_mask_spec
else:
full_fit_mask = self.fit_mask
# Weight design matrix and data by 1/sigma
#Ax = A[oktemp,:]*self.sivarf[full_fit_mask]
# Include `weight` variable to account for contamination
sivarf = self.sivarf*np.sqrt(self.weightf)
Ax = A[oktemp,:]*sivarf[full_fit_mask]
#AxT = Ax[:,full_fit_mask].T
# Scale photometry
if hasattr(self, 'pscale'):
if (self.pscale is not None):
scale = self.compute_scale_array(self.pscale, self.wavef[full_fit_mask])
if self.Nphot > 0:
scale[-self.Nphot:] = 1.
Ax *= scale
if fit_background:
for i in range(self.N):
Ax[i,:] /= scale
# Need transpose
AxT = Ax.T
# Masked data array, including background pedestal
data = ((self.scif+pedestal*self.is_spec)*sivarf)[full_fit_mask]
if get_design_matrix:
return AxT, data
# Run the minimization
if fitter == 'nnls':
coeffs_i, rnorm = scipy.optimize.nnls(AxT, data)
elif fitter == 'lstsq':
coeffs_i, residuals, rank, s = np.linalg.lstsq(AxT, data, rcond=None)
else:
# Bounded Least Squares
lsq_out = scipy.optimize.lsq_linear(AxT, data, bounds=(lower_bound[oktemp], upper_bound[oktemp]), method='bvls', tol=1.e-8)
coeffs_i = lsq_out.x
if False:
r = AxT.dot(coeffs_i) - data
# Compute background array
if fit_background:
background = np.dot(coeffs_i[:self.N], A[:self.N,:]) - pedestal
if self.Nphot > 0:
background[-self.Nphot:] = 0.
coeffs_i[:self.N] -= pedestal
else:
background = self.scif[full_fit_mask]*0.
# Full model
if fit_background:
model = np.dot(coeffs_i[self.N:], Ax[self.N:,:]/sivarf[full_fit_mask])
else:
model = np.dot(coeffs_i, Ax/sivarf[full_fit_mask])
# Model photometry
if self.Nphot > 0:
self.photom_model = model[-self.Nphot:]*1
# Residuals and Chi-squared
resid = self.scif[full_fit_mask] - model - background
if get_components:
return model, background
#chi2 = np.sum(resid[full_fit_mask]**2*self.sivarf[full_fit_mask]**2)
norm_resid = resid*(sivarf)[full_fit_mask]
# Use Huber loss function rather than direct chi2
if get_residuals:
chi2 = norm_resid
else:
if huber_delta > 0:
chi2 = huber(huber_delta, norm_resid)*2.
else:
chi2 = norm_resid**2
chi2 = np.sum(chi2)
# Uncertainties from covariance matrix
if get_uncertainties:
try:
# Covariance is inverse of AT.A
covar_i = np.matrix(np.dot(AxT.T, AxT)).I.A
covar = utils.fill_masked_covar(covar_i, oktemp)
covard = np.sqrt(covar.diagonal())
# Compute covariances after masking templates with coeffs = 0
if get_uncertainties == 2:
nonzero = coeffs_i != 0
if nonzero.sum() > 0:
AxTm = AxT[:,nonzero]
#mcoeffs_i, rnorm = scipy.optimize.nnls(AxTm, data)
#mcoeffs_i[:self.N] -= pedestal
mcovar_i = np.matrix(np.dot(AxTm.T, AxTm)).I.A
mcovar = utils.fill_masked_covar(mcovar_i, nonzero)
mcovar = utils.fill_masked_covar(mcovar, oktemp)
mcovard = np.sqrt(mcovar.diagonal())
covar = mcovar
covard = mcovard
except:
print('Except: covar!')
covar = np.zeros((self.N+NTEMP, self.N+NTEMP))
covard = np.zeros(self.N+NTEMP)#-1.
mcovard = covard
else:
covar = np.zeros((self.N+NTEMP, self.N+NTEMP))
covard = np.zeros(self.N+NTEMP)#-1.
coeffs = np.zeros(self.N+NTEMP)
coeffs[oktemp] = coeffs_i #[self.N:]] = coeffs[self.N:]
coeffs_err = covard #np.zeros(NTEMP)
#full_coeffs_err[oktemp[self.N:]] = covard[self.N:]
del(A); del(Ax); del(AxT)
#if fit_background:
coeffs[self.N:] *= COEFF_SCALE
coeffs_err[self.N:] *= COEFF_SCALE
#covar[self.N:,self.N:] *= COEFF_SCALE**2
covar[self.N:,:] *= COEFF_SCALE
covar[:,self.N:] *= COEFF_SCALE
return chi2, coeffs, coeffs_err, covar
def xfit_redshift(self, prior=None, fwhm=1200,
make_figure=True, zr=[0.65, 1.6], dz=[0.005, 0.0004],
verbose=True, fit_background=True, fitter='nnls',
delta_chi2_threshold=0.004, poly_order=3, zoom=True,
line_complexes=True, templates={}, figsize=[8,5],
fsps_templates=False, get_uncertainties=True,
Rspline=30, huber_delta=4, get_student_logpdf=False):
"""TBD
"""
from scipy import polyfit, polyval
from scipy.stats import t as student_t
from scipy.special import huber
if zr is 0:
stars = True
zr = [0, 0.01]
fitter='nnls'
else:
stars = False
zgrid = utils.log_zgrid(zr, dz=dz[0])
NZ = len(zgrid)
#### Polynomial SED fit
wpoly = np.linspace(1000,5.e4,1000)
# tpoly = utils.polynomial_templates(wpoly, line=True)
# out = self.xfit_at_z(z=0., templates=tpoly, fitter='nnls',
# fit_background=True, get_uncertainties=False)
tpoly = utils.polynomial_templates(wpoly, order=poly_order,
line=False)
out = self.xfit_at_z(z=0., templates=tpoly, fitter='lstsq',
fit_background=True, get_uncertainties=False,
include_photometry=False, huber_delta=huber_delta)
chi2_poly, coeffs_poly, err_poly, cov = out
#### Spline SED fit
wspline = np.arange(4200, 2.5e4)
#Rspline = 30
df_spl = len(utils.log_zgrid(zr=[wspline[0], wspline[-1]], dz=1./Rspline))
tspline = utils.bspline_templates(wspline, df=df_spl+2, log=True, clip=0.0001)
out = self.xfit_at_z(z=0., templates=tspline, fitter='lstsq',
fit_background=True, get_uncertainties=True,
include_photometry=False, get_residuals=True)
spline_resid, coeffs_spline, err_spline, cov = out
if huber_delta > 0:
chi2_spline = (huber(huber_delta, spline_resid)*2.).sum()
else:
chi2_spline = (spline_resid**2).sum()
student_t_pars = student_t.fit(spline_resid)
#poly1d, xxx = utils.dot_templates(coeffs_poly[self.N:], tpoly, z=0)
# tpoly = utils.polynomial_templates(wpoly, order=3)
# out = self.xfit_at_z(z=0., templates=tpoly, fitter='lstsq',
# fit_background=True)
# chi2_poly, coeffs_poly, c, cov = out
# if True:
# cp, lp = utils.dot_templates(coeffs_poly[self.N:], tpoly)
### Set up for template fit
if templates == {}:
templates = utils.load_templates(fwhm=fwhm, stars=stars, line_complexes=line_complexes, fsps_templates=fsps_templates)
else:
if verbose:
print('User templates! N={0} \n'.format(len(templates)))
NTEMP = len(templates)
out = self.xfit_at_z(z=0., templates=templates, fitter=fitter,
fit_background=fit_background,
get_uncertainties=False)
chi2, coeffs, coeffs_err, covar = out
chi2 = np.zeros(NZ)
logpdf = np.zeros(NZ)
coeffs = np.zeros((NZ, coeffs.shape[0]))
covar = np.zeros((NZ, covar.shape[0], covar.shape[1]))
chi2min = 1e30
iz = 0
for i in range(NZ):
out = self.xfit_at_z(z=zgrid[i], templates=templates,
fitter=fitter, fit_background=fit_background,
get_uncertainties=get_uncertainties,
get_residuals=True)
fit_resid, coeffs[i,:], coeffs_err, covar[i,:,:] = out
if huber_delta > 0:
chi2[i] = (huber(huber_delta, fit_resid)*2.).sum()
else:
chi2[i] = (fit_resid**2).sum()
if get_student_logpdf:
logpdf[i] = student_t.logpdf(fit_resid, *student_t_pars).sum()
if chi2[i] < chi2min:
iz = i
chi2min = chi2[i]
if verbose:
print(utils.NO_NEWLINE + ' {0:.4f} {1:9.1f} ({2:.4f}) {3:d}/{4:d}'.format(zgrid[i], chi2[i], zgrid[iz], i+1, NZ))
if verbose:
print('First iteration: z_best={0:.4f}\n'.format(zgrid[iz]))
## Find peaks
import peakutils
# Make "negative" chi2 for peak-finding
#chi2_test = chi2_poly
chi2_test = chi2_spline
if chi2_test > (chi2.min()+100):
chi2_rev = (chi2.min() + 100 - chi2)/self.DoF
elif chi2_test < (chi2.min() + 9):
chi2_rev = (chi2.min() + 16 - chi2)/self.DoF
else:
chi2_rev = (chi2_test - chi2)/self.DoF
chi2_rev[chi2_rev < 0] = 0
indexes = peakutils.indexes(chi2_rev, thres=0.4, min_dist=8)
num_peaks = len(indexes)
if False:
plt.plot(zgrid, (chi2-chi2.min())/ self.DoF)
plt.scatter(zgrid[indexes], (chi2-chi2.min())[indexes]/ self.DoF, color='r')
# delta_chi2 = (chi2.max()-chi2.min())/self.DoF
# if delta_chi2 > delta_chi2_threshold:
if (num_peaks > 0) & (not stars) & zoom:
zgrid_zoom = []
for ix in indexes:
if (ix > 0) & (ix < len(chi2)-1):
c = polyfit(zgrid[ix-1:ix+2], chi2[ix-1:ix+2], 2)
zi = -c[1]/(2*c[0])
chi_i = polyval(c, zi)
zgrid_zoom.extend(np.arange(zi-2*dz[0],
zi+2*dz[0]+dz[1]/10., dz[1]))
# zgrid_zoom = utils.zoom_zgrid(zgrid, chi2/self.DoF,
# threshold=delta_chi2_threshold,
# factor=dz[0]/dz[1])
NZOOM = len(zgrid_zoom)
chi2_zoom = np.zeros(NZOOM)
logpdf_zoom = np.zeros(NZOOM)
coeffs_zoom = np.zeros((NZOOM, coeffs.shape[1]))
covar_zoom = np.zeros((NZOOM, coeffs.shape[1], covar.shape[2]))
iz = 0
chi2min = 1.e30
for i in range(NZOOM):
out = self.xfit_at_z(z=zgrid_zoom[i], templates=templates,
fitter=fitter,
fit_background=fit_background,
get_uncertainties=get_uncertainties,
get_residuals=True)
fit_resid, coeffs_zoom[i,:], e, covar_zoom[i,:,:] = out
if huber_delta > 0:
chi2_zoom[i] = (huber(huber_delta, fit_resid)*2.).sum()
else:
chi2_zoom[i] = (fit_resid**2).sum()
if get_student_logpdf:
logpdf_zoom[i] = student_t.logpdf(fit_resid,
*student_t_pars).sum()
#A, coeffs_zoom[i,:], chi2_zoom[i], model_2d = out
if chi2_zoom[i] < chi2min:
chi2min = chi2_zoom[i]
iz = i
if verbose:
print(utils.NO_NEWLINE+'- {0:.4f} {1:9.1f} ({2:.4f}) {3:d}/{4:d}'.format(zgrid_zoom[i], chi2_zoom[i], zgrid_zoom[iz], i+1, NZOOM))
zgrid = np.append(zgrid, zgrid_zoom)
chi2 = np.append(chi2, chi2_zoom)
logpdf = np.append(logpdf, logpdf_zoom)
coeffs = np.append(coeffs, coeffs_zoom, axis=0)
covar = np.vstack((covar, covar_zoom))
so = np.argsort(zgrid)
zgrid = zgrid[so]
chi2 = chi2[so]
logpdf = logpdf[so]
coeffs = coeffs[so,:]
covar = covar[so,:,:]
fit = utils.GTable()
fit.meta['N'] = (self.N, 'Number of spectrum extensions')
fit.meta['polyord'] = (poly_order, 'Order polynomial fit')
fit.meta['chi2poly'] = (chi2_poly, 'Chi^2 of polynomial fit')
kspl = (coeffs_spline != 0).sum()
fit.meta['chi2spl'] = (chi2_spline, 'Chi^2 of spline fit')
fit.meta['kspl'] = (kspl, 'Parameters, k, of spline fit')
# Evaluate spline at wavelengths for stars
xspline = np.array([8100, 9000, 1.27e4, 1.4e4])
flux_spline = utils.eval_bspline_templates(xspline, tspline, coeffs_spline[self.N:])
fluxerr_spline = utils.eval_bspline_templates(xspline, tspline, err_spline[self.N:])
for i in range(len(xspline)):
fit.meta['splf{0:02d}'.format(i+1)] = flux_spline[i], 'Spline flux at {0:.2f} um'.format(xspline[i]/1.e4)
fit.meta['sple{0:02d}'.format(i+1)] = fluxerr_spline[i], 'Spline flux err at {0:.2f} um'.format(xspline[i]/1.e4)
izbest = np.argmin(chi2)
clip = coeffs[izbest,:] != 0
ktempl = clip.sum()
fit.meta['NTEMP'] = (len(templates), 'Number of fitting templates')
fit.meta['DoF'] = (self.DoF, 'Degrees of freedom (number of pixels)')
fit.meta['ktempl'] = (ktempl, 'Parameters, k, of template fit')
fit.meta['chimin'] = (chi2.min(), 'Minimum chi2 of template fit')
fit.meta['chimax'] = (chi2.max(), 'Maximum chi2 of template fit')
fit.meta['fitter'] = (fitter, 'Minimization algorithm')
# Bayesian information criteria, normalized to template min_chi2
# BIC = log(number of data points)*(number of params) + min(chi2) + C
# https://en.wikipedia.org/wiki/Bayesian_information_criterion
scale_chinu = self.DoF/chi2.min()
scale_chinu = 1 # Don't rescale
fit.meta['bic_poly'] = np.log(self.DoF)*(poly_order+1+self.N) + (chi2_poly-chi2.min())*scale_chinu, 'BIC of polynomial fit'
fit.meta['bic_spl'] = np.log(self.DoF)*kspl + (chi2_spline-chi2.min())*scale_chinu, 'BIC of spline fit'
fit.meta['bic_temp'] = np.log(self.DoF)*ktempl, 'BIC of template fit'
for i, tname in enumerate(templates):
fit.meta['T{0:03d}NAME'.format(i+1)] = (templates[tname].name, 'Template name')
if tname.startswith('line '):
fit.meta['T{0:03d}FWHM'.format(i+1)] = (templates[tname].fwhm, 'FWHM, if emission line')
dtype = np.float64
fit['zgrid'] = np.cast[dtype](zgrid)
fit['chi2'] = np.cast[dtype](chi2)
if get_student_logpdf:
fit['student_logpdf'] = np.cast[dtype](logpdf)
fit.meta['t_df'] = student_t_pars[0], 'Student-t df'
fit.meta['t_loc'] = student_t_pars[1], 'Student-t loc'
fit.meta['t_scale'] = student_t_pars[2], 'Student-t scale'
#fit['chi2poly'] = chi2_poly
fit['coeffs'] = np.cast[dtype](coeffs)
fit['covar'] = np.cast[dtype](covar)
fit = self._parse_zfit_output(fit, prior=prior)
return fit
def _parse_zfit_output(self, fit, prior=None):
"""Parse best-fit redshift, etc.
TBD
"""
import scipy.interpolate
# Normalize to min(chi2)/DoF = 1.
scl_nu = fit['chi2'].min()/self.DoF
# PDF
pdf = np.exp(-0.5*(fit['chi2']-fit['chi2'].min())/scl_nu)
if prior is not None:
interp_prior = np.interp(fit['zgrid'], prior[0], prior[1])
pdf *= interp_prior
fit.meta['hasprior'] = True, 'Prior applied to PDF'
fit['prior'] = interp_prior
else:
interp_prior = None
fit.meta['hasprior'] = False, 'Prior applied to PDF'
# Normalize PDF
pdf /= np.trapz(pdf, fit['zgrid'])
# Interpolate pdf for more continuous measurement
spl = scipy.interpolate.Akima1DInterpolator(fit['zgrid'], np.log(pdf), axis=1)
zfine = utils.log_zgrid(zr=[fit['zgrid'].min(), fit['zgrid'].max()], dz=0.0001)
ok = np.isfinite(spl(zfine))
norm = np.trapz(np.exp(spl(zfine[ok])), zfine[ok])
# Compute CDF and probability intervals
dz = np.gradient(zfine[ok])
cdf = np.cumsum(np.exp(spl(zfine[ok]))*dz/norm)
pz_percentiles = np.interp(np.array([2.5, 16, 50, 84, 97.5])/100., cdf, zfine[ok])
# Random draws, testing
#rnd = np.interp(np.random.rand(1000), cdf, fit['zgrid']+dz/2.)
dz = np.gradient(fit['zgrid'])
gamma = 0.15
zsq = np.dot(fit['zgrid'][:,None], np.ones_like(fit['zgrid'])[None,:])
L = _loss((zsq-fit['zgrid'])/(1+fit['zgrid']), gamma=gamma)
risk = np.dot(pdf*L, dz)
zi = np.argmin(risk)
#print('xxx', zi, len(risk))
if (zi < len(risk)-1) & (zi > 0):
c = np.polyfit(fit['zgrid'][zi-1:zi+2], risk[zi-1:zi+2], 2)
z_risk = -c[1]/(2*c[0])
else:
z_risk = fit['zgrid'][zi]
min_risk = np.trapz(pdf*_loss((z_risk-fit['zgrid'])/(1+fit['zgrid']), gamma=gamma), fit['zgrid'])
# MAP, maximum p(z)
zi = np.argmax(pdf)
if (zi < len(pdf)-1) & (zi > 0):
c = np.polyfit(fit['zgrid'][zi-1:zi+2], pdf[zi-1:zi+2], 2)
z_map = -c[1]/(2*c[0])
else:
z_map = fit['zgrid'][zi]
# Store data in the fit table
fit['pdf'] = pdf
fit['risk'] = risk
fit.meta['Z02'] = pz_percentiles[0], 'Integrated p(z) = 0.025'
fit.meta['Z16'] = pz_percentiles[1], 'Integrated p(z) = 0.16'
fit.meta['Z50'] = pz_percentiles[2], 'Integrated p(z) = 0.5'
fit.meta['Z84'] = pz_percentiles[3], 'Integrated p(z) = 0.84'
fit.meta['Z97'] = pz_percentiles[4], 'Integrated p(z) = 0.975'
fit.meta['ZWIDTH1'] = pz_percentiles[3]-pz_percentiles[1], 'Width between the 16th and 84th p(z) percentiles'
fit.meta['ZWIDTH2'] = pz_percentiles[4]-pz_percentiles[0], 'Width between the 2.5th and 97.5th p(z) percentiles'
fit.meta['z_map'] = z_map, 'Redshift at MAX(PDF)'
fit.meta['z_risk'] = z_risk, 'Redshift at minimum risk'
fit.meta['min_risk'] = min_risk, 'Minimum risk'
fit.meta['gam_loss'] = gamma, 'Gamma factor of the risk/loss function'
return fit
def template_at_z(self, z=0, templates=None, fit_background=True, fitter='nnls', fwhm=1400, get_uncertainties=2, get_residuals=False, include_photometry=True, draws=0):
"""TBD
"""
if templates is None:
templates = utils.load_templates(line_complexes=False, fsps_templates=True, fwhm=fwhm)
out = self.xfit_at_z(z=z, templates=templates, fitter=fitter,
fit_background=fit_background,
get_uncertainties=get_uncertainties,
get_residuals=get_residuals,
include_photometry=include_photometry)
chi2, coeffs, coeffs_err, covar = out
cont1d, line1d = utils.dot_templates(coeffs[self.N:], templates, z=z,
apply_igm=(z > IGM_MINZ))
# Parse template coeffs
cfit = OrderedDict()
for i in range(self.N):
cfit['bg {0:03d}'.format(i)] = coeffs[i], coeffs_err[i]
for j, key in enumerate(templates):
i = j+self.N
cfit[key] = coeffs[i], coeffs_err[i]
if False:
# Compare drizzled and beam fits (very close)
for j, key in enumerate(templates):
print('{key:<16s} {0:.2e} {1:.2e} {2:.2e} {3:.2e}'.format(mb_cfit[key][0], mb_cfit[key][1], st_cfit[key][0], st_cfit[key][1], key=key))
tfit = OrderedDict()
tfit['cont1d'] = cont1d
tfit['line1d'] = line1d
tfit['cfit'] = cfit
tfit['coeffs'] = coeffs
tfit['chi2'] = chi2
tfit['covar'] = covar
tfit['z'] = z
tfit['templates'] = templates
if draws > 0:
xte, yte, lte = utils.array_templates(templates, max_R=5000, z=z)
err = np.sqrt(covar.diagonal())
nonzero = err > 0
cov_norm = ((covar/err).T/err)[nonzero,:][:,nonzero]
draw_coeff = np.zeros((draws, len(err)))
draw_coeff[:,nonzero] = np.random.multivariate_normal((coeffs/err)[nonzero], cov_norm, draws)*err[nonzero]
draw_spec = draw_coeff[:,self.N:].dot(yte)
err_spec = np.diff(np.percentile(draw_spec, [16,84], axis=0), axis=0).flatten()/2.
tfit['line1d_err'] = err_spec
return tfit #cont1d, line1d, cfit, covar
### Random draws
# Unique wavelengths
wfull = np.hstack([templates[key].wave for key in templates])
w = np.unique(wfull)
so = np.argsort(w)
w = w[so]
xclip = (w*(1+z) > 7000) & (w*(1+z) < 1.8e4)
temp = []
for key in templates:
if key.startswith('bspl'):
temp.append(grizli.utils_c.interp.interp_conserve_c(w[xclip]/(1+z), templates[key].wave, templates[key].flux))
else:
temp.append(grizli.utils_c.interp.interp_conserve_c(w[xclip], templates[key].wave, templates[key].flux))
temp = np.vstack(temp)
#array([) for key in templates])
clip = coeffs_err[self.N:] > 0
covar_clip = covar[self.N:,self.N:][clip,:][:,clip]
draws = np.random.multivariate_normal(coeffs[self.N:][clip], covar_clip, size=100)
tdraw = np.dot(draws, temp[clip,:])/(1+z)
for ib, beam in enumerate(self.beams):
ww, ff, ee = beam.optimal_extract(beam.sci - beam.contam - coeffs[ib])
plt.errorbar(ww, ff/beam.sens, ee/beam.sens, color='k', marker='.', linestyle='None', alpha=0.5)
for i in range(tdraw.shape[0]):
sp = [w[xclip]*(1+z), tdraw[i,:]]
m = beam.compute_model(spectrum_1d=sp, is_cgs=True, in_place=False).reshape(beam.sh)
ww, ff, ee = beam.optimal_extract(m)
plt.plot(ww, ff/beam.sens, color='r', alpha=0.05)
plt.plot(w[xclip]*(1+z), tdraw.T, alpha=0.05, color='r')
def xmake_fit_plot(self, fit, tfit, show_beams=True, bin=1, minor=0.1,
scale_on_stacked_1d=True):
"""TBD
"""
import matplotlib.pyplot as plt
import matplotlib.gridspec
from matplotlib.ticker import MultipleLocator
import grizli.model
# Initialize plot window
Ng = len(self.grisms)
gs = matplotlib.gridspec.GridSpec(1,2,
width_ratios=[1,1.5+0.5*(Ng>1)],
hspace=0.)
fig = plt.figure(figsize=[8+4*(Ng>1), 3.5])
# p(z)
axz = fig.add_subplot(gs[-1,0]) #121)
axz.text(0.95, 0.96, self.group_name + '\n'+'ID={0:<5d} z={1:.4f}'.format(self.id, fit.meta['z_map'][0]), ha='right', va='top', transform=axz.transAxes, fontsize=9)
axz.plot(fit['zgrid'], np.log10(fit['pdf']), color='k')
#axz.fill_between(z, (chi2-chi2.min())/scale_nu, 27, color='k', alpha=0.5)
axz.set_xlabel(r'$z$')
axz.set_ylabel(r'$\log\ p(z)$'+' / '+ r'$\chi^2=\frac{{{0:.0f}}}{{{1:d}}}={2:.2f}$'.format(fit.meta['chimin'][0], fit.meta['DoF'][0], fit.meta['chimin'][0]/fit.meta['DoF'][0]))
#axz.set_yticks([1,4,9,16,25])
axz.set_xlim(fit['zgrid'].min(), fit['zgrid'].max())
pzmax = np.log10(fit['pdf'].max())
axz.set_ylim(pzmax-6, pzmax+0.8)
axz.grid()
axz.yaxis.set_major_locator(MultipleLocator(base=1))
#### Spectra
axc = fig.add_subplot(gs[-1,1]) #224)
self.oned_figure(bin=bin, show_beams=show_beams, minor=minor, tfit=tfit, axc=axc, scale_on_stacked=scale_on_stacked_1d)
gs.tight_layout(fig, pad=0.1, w_pad=0.1)
return fig
def process_zfit(self, zgrid, chi2, prior=None):
"""Parse redshift fit"""
zbest = zgrid[np.argmin(chi2)]
###############
if prior is not None:
#print('\n\nPrior!\n\n', chi2.min(), prior[1].min())
interp_prior = np.interp(zgrid, prior[0], prior[1])
chi2 += interp_prior
else:
interp_prior = None
print(' Zoom iteration: z_best={0:.4f}\n'.format(zgrid[np.argmin(chi2)]))
### Best redshift
if not stars:
templates = utils.load_templates(line_complexes=False, fwhm=fwhm, fsps_templates=fsps_templates)
zbest = zgrid[np.argmin(chi2)]
ix = np.argmin(chi2)
chibest = chi2.min()
## Fit parabola
if (ix > 0) & (ix < len(chi2)-1):
c = polyfit(zgrid[ix-1:ix+2], chi2[ix-1:ix+2], 2)
zbest = -c[1]/(2*c[0])
chibest = polyval(c, zbest)
out = self.fit_at_z(z=zbest, templates=templates,
fitter=fitter, poly_order=poly_order,
fit_background=fit_background)
A, coeffs_full, chi2_best, model_full = out
# Parse results
out2 = self.parse_fit_outputs(zbest, templates, coeffs_full, A)
line_flux, covar, cont1d, line1d, model1d, model_continuum = out2
# Output dictionary with fit parameters
fit_data = OrderedDict()
fit_data['poly_order'] = poly_order
fit_data['fwhm'] = fwhm
fit_data['zbest'] = zbest
fit_data['chibest'] = chibest
fit_data['chi_poly'] = chi2_poly
fit_data['zgrid'] = zgrid
fit_data['prior'] = interp_prior
fit_data['A'] = A
fit_data['coeffs'] = coeffs
fit_data['chi2'] = chi2
fit_data['DoF'] = self.DoF
fit_data['model_full'] = model_full
fit_data['coeffs_full'] = coeffs_full
fit_data['covar'] = covar
fit_data['line_flux'] = line_flux
#fit_data['templates_full'] = templates
fit_data['model_cont'] = model_continuum
fit_data['model1d'] = model1d
fit_data['cont1d'] = cont1d
fit_data['line1d'] = line1d
def scale_to_photometry(self, tfit=None, tol=1.e-4, order=0, init=None, fit_background=True, Rspline=50, use_fit=True, **kwargs):
"""Compute scale factor between spectra and photometry
method : 'Powell' or 'BFGS' work well, latter a bit faster but less robust
New implementation of Levenberg-Markwardt minimization
TBD
"""
from scipy.optimize import minimize, least_squares
if self.Nphot == 0:
return np.array([10.])
if (tfit is None) & (fit_background):
wspline = np.arange(4200, 2.5e4)
#Rspline = 50
df_spl = len(utils.log_zgrid(zr=[wspline[0], wspline[-1]], dz=1./Rspline))
tspline = utils.bspline_templates(wspline, df=df_spl+2, log=True, clip=0.0001)
tfit = self.template_at_z(z=0, templates=tspline, include_photometry=False, fit_background=fit_background, draws=1000)
if use_fit:
oned = self.oned_spectrum(tfit=tfit)
wmi = np.min([oned[k]['wave'].min() for k in oned])
wma = np.max([oned[k]['wave'].max() for k in oned])
clip = (tfit['line1d'].wave > wmi) & (tfit['line1d'].wave < wma) & (tfit['line1d_err'] > 0)
spl_temp = utils.SpectrumTemplate(wave=tfit['line1d'].wave[clip], flux=tfit['line1d'].flux[clip], err=tfit['line1d_err'][clip])
args = (self, {'spl':spl_temp})
else:
oned = self.oned_spectrum(tfit=tfit)
args = (self, oned)
if init is None:
init = np.zeros(order+1)
init[0] = 10.
scale_fit = least_squares(self._objective_scale_direct, init, jac='2-point', method='lm', ftol=tol, xtol=tol, gtol=tol, x_scale=1.0, loss='linear', f_scale=1.0, diff_step=None, tr_solver=None, tr_options={}, jac_sparsity=None, max_nfev=None, verbose=0, args=args, kwargs={})
# pscale = scale_fit.x
return scale_fit
def _old_scale_to_photometry(self, z=0, templates={}, tol=1.e-4, order=0, init=None, method='lm', fit_background=True):
"""Compute scale factor between spectra and photometry
method : 'Powell' or 'BFGS' work well, latter a bit faster but less robust
New implementation of Levenberg-Markwardt minimization
TBD
"""
from scipy.optimize import minimize, least_squares
if self.Nphot == 0:
return np.array([10.])
AxT, data = self.xfit_at_z(z=z, templates=templates, fitter='nnls',
fit_background=fit_background,
get_uncertainties=False,
get_design_matrix=True)
if init is None:
init = np.zeros(order+1)
init[0] = 10.
if method == 'lm':
scale_fit = least_squares(self.objfun_scale, init, jac='2-point', method='lm', ftol=tol, xtol=tol, gtol=tol, x_scale=1.0, loss='linear', f_scale=1.0, diff_step=None, tr_solver=None, tr_options={}, jac_sparsity=None, max_nfev=None, verbose=0, args=(AxT, data, self, 'resid'), kwargs={})
else:
scale_fit = minimize(self.objfun_scale, init, args=(AxT, data, self, 'chi2'), method=method, jac=None, hess=None, hessp=None, tol=tol, callback=None, options=None)
# pscale = scale_fit.x
return scale_fit
@staticmethod
def compute_scale_array(pscale, wave):
"""Return the scale array given the input coefficients
TBD
"""
N = len(pscale)
rescale = 10**(np.arange(N)+1)
return np.polyval((pscale/rescale)[::-1], (wave-1.e4)/1000.)
@staticmethod
def objfun_scale(pscale, AxT, data, self, retval):
"""
Objective function for fitting for a scale term between photometry and
spectra
"""
import scipy.optimize
from scipy import polyval
scale = self.compute_scale_array(pscale, self.wavef[self.fit_mask])
scale[-self.Nphot:] = 1.
Ax = (AxT.T*scale)
# Remove scaling from background component
for i in range(self.N):
Ax[i,:] /= scale
coeffs, rnorm = scipy.optimize.nnls(Ax.T, data)
#coeffs, rnorm, rank, s = np.linalg.lstsq(Ax.T, data)
full = np.dot(coeffs, Ax)
resid = data - full# - background
chi2 = np.sum(resid**2*self.weightf[self.fit_mask])
print('{0} {1:.1f}'.format(' '.join(['{0:6.2f}'.format(p) for p in pscale]), chi2))
if retval == 'resid':
return resid*np.sqrt(self.weightf[self.fit_mask])
if retval == 'coeffs':
return coeffs, full, resid, chi2, AxT
else:
return chi2
@staticmethod
def _objective_scale_direct(pscale, self, oned):
from eazy.filters import FilterDefinition
flam = []
eflam = []
spec_flux = []
filters = []
for filt in self.photom_filters:
clip = filt.throughput > 0.001*filt.throughput.max()
filters.append(FilterDefinition(name=filt.name,
wave=filt.wave[clip],
throughput=filt.throughput[clip]))
filters = np.array(filters)
lc = self.photom_pivot
for k in oned:
#spec, okfilt, lc = spec1d[k]
# Covered filters
if isinstance(oned[k], utils.SpectrumTemplate):
spec1 = utils.SpectrumTemplate(wave=oned[k].wave, flux=3.e18/oned[k].wave**2)
else:
spec1 = utils.SpectrumTemplate(wave=oned[k]['wave'], flux=3.e18/oned[k]['wave']**2)
flux1 = np.array([spec1.integrate_filter(filt, use_wave='filter') for filt in filters])
okfilt = flux1 > 0.98
if okfilt.sum() == 0:
#print('scale_to_photometry: no filters overlap '+k)
continue
if isinstance(oned[k], utils.SpectrumTemplate):
scale = 1./self.compute_scale_array(pscale, oned[k].wave)
spec = utils.SpectrumTemplate(wave=oned[k].wave, flux=oned[k].flux*scale, err=oned[k].err*scale)
else:
scale = 1./self.compute_scale_array(pscale, oned[k]['wave'])
spec = utils.SpectrumTemplate(wave=oned[k]['wave'], flux=oned[k]['flux']*scale/np.maximum(oned[k]['flat'], 1), err=oned[k]['err']*scale/np.maximum(oned[k]['flat'], 1))
spec_flux.append((np.array([spec.integrate_filter(filt, use_wave='templ') for filt in filters[okfilt]]).T*3.e18/lc[okfilt]**2).T)
flam.append(self.photom_flam[okfilt])
eflam.append(self.photom_eflam[okfilt])
if not flam:
return [0]
spec_flux = np.vstack(spec_flux)
flam = np.hstack(flam)
eflam = np.hstack(eflam)
chi2 = (flam-spec_flux[:,0])**2/(eflam**2+spec_flux[:,1]**2)
#print(pscale, chi2.sum())
return chi2
def xfit_star(self, tstar=None, spline_correction=True, fitter='nnls', fit_background=True, spline_args={'Rspline':5}, oned_args={}):
"""Fit stellar templates
"""
import matplotlib.pyplot as plt
import matplotlib.gridspec
from matplotlib.ticker import MultipleLocator
#self = grizli.multifit.MultiBeam('ers-grism_{0:05d}.beams.fits'.format(id), fcontam=0.2, psf=True)
#self.extend(grizli.multifit.MultiBeam('/Volumes/Pegasus/Grizli/ACS/goodss/Prep/ers-grism-pears_{0:05d}.beams.fits'.format(id), fcontam=0.2))
if tstar is None:
tstar = utils.load_templates(fwhm=1200, line_complexes=True, fsps_templates=True, stars=True)
NTEMP = len(tstar)
#covar = np.zeros((NTEMP, self.N+1, self.N+1))
#coeffs = np.zeros((NTEMP, self.N+1))
chi2 = | np.zeros(NTEMP) | numpy.zeros |
# Class definitions for equations to be tested
# from path import *
import numpy as np
import centpy
###############
# 1D equations
###############
# Burgers equation
class Burgers1d(centpy.Equation1d):
def initial_data(self):
return np.sin(self.x) + 0.5 * np.sin(0.5 * self.x)
def boundary_conditions(self, u):
u[0] = u[-4]
u[1] = u[-3]
u[-2] = u[2]
u[-1] = u[3]
def flux_x(self, u):
return 0.5 * u * u
def spectral_radius_x(self, u):
return np.abs(u)
# Euler equation
class Euler1d(centpy.Equation1d):
def initial_data(self):
u = np.zeros((self.J + 4, 3))
midpoint = int(self.J / 2) + 2
left_v = [1, 0, 1.0 / (self.gamma - 1.0)]
right_v = [0.125, 0.0, 0.1 / (self.gamma - 1.0)]
# Left side
u[:midpoint, :] = left_v
# Right side
u[midpoint:, :] = right_v
return u
def boundary_conditions(self, u):
left_v = [1, 0, 1.0 / (self.gamma - 1.0)]
right_v = [0.125, 0.0, 0.1 / (self.gamma - 1.0)]
# Left side
u[0] = left_v
u[1] = left_v
# Right side
u[-1] = right_v
u[-2] = right_v
def flux_x(self, u):
f = np.zeros_like(u)
rho = u[:, 0]
u_x = u[:, 1] / rho
E = u[:, 2]
p = (self.gamma - 1.0) * (E - 0.5 * rho * u_x ** 2)
f[:, 0] = rho * u_x
f[:, 1] = rho * u_x ** 2 + p
f[:, 2] = u_x * (E + p)
return f
def spectral_radius_x(self, u):
rho = u[:, 0]
u_x = u[:, 1] / rho
p = (self.gamma - 1.0) * (u[:, 2] - 0.5 * rho * u_x ** 2)
return np.abs(u_x) + np.sqrt(self.gamma * p / rho)
# MHD equation
class MHD1d(centpy.Equation1d):
def pressure(self, u):
return (
u[:, 6]
- 0.5 * ((u[:, 1] ** 2 + u[:, 2] ** 2 + u[:, 3] ** 2) / u[:, 0])
- 0.5 * (self.B1 ** 2 + u[:, 4] ** 2 + u[:, 5] ** 2)
)
def initial_data(self):
u = np.zeros((self.J + 4, 7))
midpoint = int(self.J / 2) + 2
# Left side
u[:midpoint, 0] = 1.0
u[:midpoint, 1] = 0.0
u[:midpoint, 2] = 0.0
u[:midpoint, 3] = 0.0
u[:midpoint, 4] = 1.0
u[:midpoint, 5] = 0.0
u[:midpoint, 6] = 1.0 + 25.0 / 32.0
# Right side
u[midpoint:, 0] = 0.125
u[midpoint:, 1] = 0.0
u[midpoint:, 2] = 0.0
u[midpoint:, 3] = 0.0
u[midpoint:, 4] = -1.0
u[midpoint:, 5] = 0.0
u[midpoint:, 6] = 0.1 + 25.0 / 32.0
return u
def boundary_conditions(self, u):
left_v = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0 + 25.0 / 32.0]
right_v = [0.125, 0.0, 0.0, 0.0, -1.0, 0.0, 0.1 + 25.0 / 32]
if self.odd:
u[0] = left_v
u[-1] = right_v
u[-2] = right_v
else:
u[0] = left_v
u[1] = left_v
u[-1] = right_v
def flux_x(self, u):
f = np.zeros_like(u)
B1 = self.B1
p_star = self.pressure(u) + 0.5 * (B1 ** 2 + u[:, 4] ** 2 + u[:, 5] ** 2)
f[:, 0] = u[:, 1]
f[:, 1] = u[:, 1] ** 2 / u[:, 0] + p_star
f[:, 2] = u[:, 1] * u[:, 2] / u[:, 0] - B1 * u[:, 4]
f[:, 3] = u[:, 1] * u[:, 3] / u[:, 0] - B1 * u[:, 5]
f[:, 4] = u[:, 1] * u[:, 4] / u[:, 0] - B1 * u[:, 2] / u[:, 0]
f[:, 5] = u[:, 1] * u[:, 5] / u[:, 0] - B1 * u[:, 3] / u[:, 0]
f[:, 6] = (u[:, 6] + p_star) * (u[:, 1] / u[:, 0]) - B1 * (
B1 * u[:, 1] + u[:, 2] * u[:, 4] + u[:, 3] * u[:, 5]
) / u[:, 0]
return f
def spectral_radius_x(self, u):
rho = u[:, 0]
u_x = u[:, 1] / rho
p = self.pressure(u)
A = 2.0 * p / rho
B = (self.B1 ** 2 + u[:, 4] ** 2 + u[:, 5] ** 2) / rho
cf = np.sqrt(
0.5 * (A + B + np.sqrt((A + B) ** 2 - 4.0 * A * self.B1 ** 2 / rho))
)
return np.abs(u_x) + cf
###############
# 2D equations
###############
# Scalar equation
class Scalar2d(centpy.Equation2d):
def initial_data(self):
return np.sin(self.xx.T + 0.5) * np.cos(2 * self.xx.T + self.yy.T)
def boundary_conditions(self, u):
# x-boundary
u[0] = u[-4]
u[1] = u[-3]
u[-2] = u[2]
u[-1] = u[3]
# y-boundary
u[:, 0] = u[:, -4]
u[:, 1] = u[:, -3]
u[:, -2] = u[:, 2]
u[:, -1] = u[:, 3]
def flux_x(self, u):
return np.sin(u)
def flux_y(self, u):
return 1.0 / 3.0 * u ** 3
def spectral_radius_x(self, u):
return np.abs(np.cos(u))
def spectral_radius_y(self, u):
return u**2
# Euler equation
class Euler2d(centpy.Equation2d):
# Helper functions and definitions for the equation
def pressure(self, u):
return (self.gamma - 1.0) * (
u[:, :, 3] - 0.5 * (u[:, :, 1] ** 2 + u[:, :, 2] ** 2) / u[:, :, 0]
)
def euler_data(self):
gamma = self.gamma
p_one = 1.5
p_two = 0.3
p_three = 0.029
p_four = 0.3
upper_right, upper_left, lower_right, lower_left = np.ones((4, 4))
upper_right[0] = 1.5
upper_right[1] = 0.0
upper_right[2] = 0.0
upper_right[3] = (
p_one / (gamma - 1.0)
+ 0.5 * (upper_right[1] ** 2 + upper_right[2] ** 2) / upper_right[0]
)
upper_left[0] = 0.5323
upper_left[1] = 1.206 * upper_left[0]
upper_left[2] = 0.0
upper_left[3] = (
p_two / (gamma - 1.0)
+ 0.5 * (upper_left[1] ** 2 + upper_left[2] ** 2) / upper_left[0]
)
lower_right[0] = 0.5323
lower_right[1] = 0.0
lower_right[2] = 1.206 * lower_right[0]
lower_right[3] = (
p_four / (gamma - 1.0)
+ 0.5 * (lower_right[1] ** 2 + lower_right[2] ** 2) / lower_right[0]
)
lower_left[0] = 0.138
lower_left[1] = 1.206 * lower_left[0]
lower_left[2] = 1.206 * lower_left[0]
lower_left[3] = (
p_three / (gamma - 1.0)
+ 0.5 * (lower_left[1] ** 2 + lower_left[2] ** 2) / lower_left[0]
)
return upper_right, upper_left, lower_right, lower_left
# Abstract class equation definitions
def initial_data(self):
u = np.empty((self.J + 4, self.K + 4, 4))
midJ = int(self.J / 2) + 2
midK = int(self.K / 2) + 2
one_matrix = np.ones(u[midJ:, midK:].shape)
upper_right, upper_left, lower_right, lower_left = self.euler_data()
u[midJ:, midK:] = upper_right * one_matrix
u[:midJ, midK:] = upper_left * one_matrix
u[midJ:, :midK] = lower_right * one_matrix
u[:midJ, :midK] = lower_left * one_matrix
return u
def boundary_conditions(self, u):
upper_right, upper_left, lower_right, lower_left = self.euler_data()
if self.odd:
j = slice(1, -2)
u[j, 0] = u[j, 1]
u[j, -2] = u[j, -3]
u[j, -1] = u[j, -3]
u[0, j] = u[1, j]
u[-2, j] = u[-3, j]
u[-1, j] = u[-3, j]
# one
u[-2, -2] = upper_right
u[-1, -2] = upper_right
u[-2, -1] = upper_right
u[-1, -1] = upper_right
# two
u[0, -2] = upper_left
u[0, -1] = upper_left
# three
u[0, 0] = lower_left
u[0, 1] = lower_left
u[1, 0] = lower_left
u[1, 1] = lower_left
# four
u[-2, 0] = lower_right
u[-1, 0] = lower_right
u[-2, 1] = lower_right
u[-1, 1] = lower_right
else:
j = slice(2, -1)
u[j, 0] = u[j, 2]
u[j, 1] = u[j, 2]
u[j, -1] = u[j, -2]
u[0, j] = u[2, j]
u[1, j] = u[2, j]
u[-1, j] = u[-2, j]
# one
u[-1, -2] = upper_right
u[-1, -1] = upper_right
# two
u[0, -2] = upper_left
u[0, -1] = upper_left
u[1, -2] = upper_left
u[1, -1] = upper_left
# three
u[0, 0] = lower_left
u[0, 1] = lower_left
u[1, 0] = lower_left
u[1, 1] = lower_left
# four
u[-1, 0] = lower_right
u[-1, 1] = lower_right
def flux_x(self, u):
f = np.empty_like(u)
p = self.pressure(u)
f[:, :, 0] = u[:, :, 1]
f[:, :, 1] = u[:, :, 1] ** 2 / u[:, :, 0] + p
f[:, :, 2] = u[:, :, 1] * u[:, :, 2] / u[:, :, 0]
f[:, :, 3] = (u[:, :, 3] + p) * u[:, :, 1] / u[:, :, 0]
return f
def flux_y(self, u):
g = np.empty_like(u)
p = self.pressure(u)
g[:, :, 0] = u[:, :, 2]
g[:, :, 1] = u[:, :, 1] * u[:, :, 2] / u[:, :, 0]
g[:, :, 2] = u[:, :, 2] ** 2 / u[:, :, 0] + p
g[:, :, 3] = (u[:, :, 3] + p) * u[:, :, 2] / u[:, :, 0]
return g
def spectral_radius_x(self, u):
j0 = centpy._helpers.j0
rho = u[j0, j0, 0]
vx = u[j0, j0, 1] / rho
vy = u[j0, j0, 2] / rho
p = (self.gamma - 1.0) * (u[j0, j0, 3] - 0.5 * rho * (vx ** 2 + vy ** 2))
c = np.sqrt(self.gamma * p / rho)
return np.abs(vx) + c
def spectral_radius_y(self, u):
j0 = centpy._helpers.j0
rho = u[j0, j0, 0]
vx = u[j0, j0, 1] / rho
vy = u[j0, j0, 2] / rho
p = (self.gamma - 1.0) * (u[j0, j0, 3] - 0.5 * rho * (vx ** 2 + vy ** 2))
c = | np.sqrt(self.gamma * p / rho) | numpy.sqrt |
import argparse
import os
import json
import numpy as np
import PIL.Image as Image
import xml.etree.ElementTree as ET
from simplification.cutil import simplify_coords
from skimage import measure
def convert_mask_to_polygon(
mask,
max_polygon_points=100,
score_threshold=0.5,
max_refinement_iterations=25,
edge_safety_padding=1,
):
"""Convert a numpy mask to a polygon outline in normalized coordinates.
:param mask: Pixel mask, where each pixel has an object (float) score in [0, 1], in size ([1, height, width])
:type: mask: <class 'numpy.array'>
:param max_polygon_points: Maximum number of (x, y) coordinate pairs in polygon
:type: max_polygon_points: Int
:param score_threshold: Score cutoff for considering a pixel as in object.
:type: score_threshold: Float
:param max_refinement_iterations: Maximum number of times to refine the polygon
trying to reduce the number of pixels to meet max polygon points.
:type: max_refinement_iterations: Int
:param edge_safety_padding: Number of pixels to pad the mask with
:type edge_safety_padding: Int
:return: normalized polygon coordinates
:rtype: list of list
"""
# Convert to numpy bitmask
mask = mask[0]
mask_array = np.array((mask > score_threshold), dtype=np.uint8)
image_shape = mask_array.shape
# Pad the mask to avoid errors at the edge of the mask
embedded_mask = np.zeros(
(
image_shape[0] + 2 * edge_safety_padding,
image_shape[1] + 2 * edge_safety_padding,
),
dtype=np.uint8,
)
embedded_mask[
edge_safety_padding : image_shape[0] + edge_safety_padding,
edge_safety_padding : image_shape[1] + edge_safety_padding,
] = mask_array
# Find Image Contours
contours = measure.find_contours(embedded_mask, 0.5)
simplified_contours = []
for contour in contours:
# Iteratively reduce polygon points, if necessary
if max_polygon_points is not None:
simplify_factor = 0
while (
len(contour) > max_polygon_points
and simplify_factor < max_refinement_iterations
):
contour = simplify_coords(contour, simplify_factor)
simplify_factor += 1
# Convert to [x, y, x, y, ....] coordinates and correct for padding
unwrapped_contour = [0] * (2 * len(contour))
unwrapped_contour[::2] = | np.ceil(contour[:, 1]) | numpy.ceil |
import numpy as np
import matplotlib.pyplot as plt
from randomWalk_setup import get_episode_randomWalk19
from TD import TD_n
v_true = np.arange(-9,10) / 10
random_policy = np.ones([21,2]) / 2
initial_v = | np.zeros(21) | numpy.zeros |
# coding: utf-8
import os
import sys
import json
import numpy as np
import torch
import scipy.sparse
from nltk.tokenize import TweetTokenizer
from allennlp.modules.elmo import Elmo, batch_to_ids
# from allennlp.commands.elmo import ElmoEmbedder
from hyperpara import *
# Initialization for Tokenizer and Elmo Embedder
tokenize = TweetTokenizer().tokenize
# Setting for Elmo Embedder - CHANGE THE PATH
options_file = '/afs/inf.ed.ac.uk/user/s20/s2041332/mlp_project/src/elmo_2x4096_512_2048cnn_2xhighway_options.json'
weight_file = '/afs/inf.ed.ac.uk/user/s20/s2041332/mlp_project/src/elmo_2x4096_512_2048cnn_2xhighway_weights'
ee = Elmo(options_file, weight_file, 3, dropout=0)
def check(s, wi, c):
return sum([s[wi + j].lower() == c_ for j, c_ in enumerate(c) if wi + j < len(s)]) == len(c)
def ind(si, wi, ci, c):
return [[si, wi + i, ci] for i in range(len(c))]
def next_batch(data_mb):
for d in data_mb:
d['query'] = tokenize(d['query'])
d['candidates_orig'] = list(d['candidates'])
d['candidates'] = [tokenize(c) for c in d['candidates']]
d['supports'] = [tokenize(s) for s in d['supports']]
mask = [[ind(si, wi, ci, c) for wi, w in enumerate(s) for ci, c in enumerate(d['candidates'])
if check(s, wi, c)] for si, s in enumerate(d['supports'])]
nodes_id_name = []
c = 0
for e in [[[x[-1] for x in c][0] for c in s] for s in mask]:
u = []
for f in e:
u.append((c, f))
c +=1
nodes_id_name.append(u)
d['nodes_candidates_id'] = [[x[-1] for x in f][0] for e in mask for f in e]
edges_in, edges_out = [], []
for e0 in nodes_id_name:
for f0, w0 in e0:
for f1, w1 in e0:
if f0 != f1:
edges_in.append((f0, f1))
for e1 in nodes_id_name:
for f1, w1 in e1:
if e0 !=e1 and w0 == w1:
edges_out.append((f0, f1))
d['edges_in'] = edges_in
d['edges_out'] = edges_out
mask_ = [[x[:-1] for x in f] for e in mask for f in e]
# Note: the output shape of ELMo:
# AllenNLP 0.9 (original paper): ee.batch_to_embeddings: (batch_size, 3, num_timesteps, 1024)
# AllenNLP 2.0 (current version): ee(supports_ids)['elmo_representations']: [(batch_size, timesteps, embedding_dim), (batch_size, timesteps, embedding_dim), (batch_size, timesteps, embedding_dim)]
# print(len(np.array(d['supports']))) # num_sentence * len_sentence
supports_ids = batch_to_ids(d['supports']) # padding operation
# print(supports_ids.shape) # (8, 147, 50) - (batchsize, max sentence length, max word length)
candidates = ee(supports_ids)['elmo_representations'] # [(batch_size, timesteps, embedding_dim) * 3]
candidates = torch.stack(candidates) # (3, batch_size, timesteps, embedding_dim)
candidates = candidates.data.cpu().numpy().transpose((1,0,2,3)) # align with the 0.9 allenNLP
d['nodes_elmo'] = [(candidates.transpose((0, 2, 1, 3))[np.array(m).T.tolist()]).astype(np.float16)
for m in mask_]
query_ids = batch_to_ids(d['query']) # padding operation
query = ee(query_ids)['elmo_representations']
query = torch.stack(query)
query = query.data.cpu().numpy().transpose((1,0,2,3))
d['query_elmo'] = (query.transpose((0, 2, 1, 3))).astype(np.float16)[0]
id_mb = [d['id'] for d in data_mb]
candidates_mb = [d['candidates_orig'] for d in data_mb]
filt = lambda c: np.array([c[:,0].mean(0), c[-1,1], c[0,2]])
nodes_mb = np.array([np.pad(np.array([filt(c) for c in d['nodes_elmo']]),
((0, max_nodes - len(d['nodes_candidates_id'])), (0, 0), (0, 0)),
mode='constant')
for d in data_mb])
nodes_length_mb = np.stack([len(d['nodes_candidates_id']) for d in data_mb] , 0)
query_mb = np.stack([np.pad(d['query_elmo'],
((0, max_query_size - d['query_elmo'].shape[0]), (0, 0), (0, 0)),
mode='constant')
for d in data_mb], 0)
query_length_mb = np.stack([d['query_elmo'].shape[0] for d in data_mb], 0)
adj_mb = []
for d in data_mb:
adj_ = []
if len(d['edges_in']) == 0:
adj_.append( | np.zeros((max_nodes, max_nodes)) | numpy.zeros |
#
# Copyright (C) 2019 Databricks, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import datetime
from distutils.version import LooseVersion
import unittest
import numpy as np
import pandas as pd
from databricks import koalas as ks
from databricks.koalas.exceptions import SparkPandasIndexingError
from databricks.koalas.testing.utils import ComparisonTestBase, ReusedSQLTestCase, compare_both
class BasicIndexingTest(ComparisonTestBase):
@property
def pdf(self):
return pd.DataFrame(
{"month": [1, 4, 7, 10], "year": [2012, 2014, 2013, 2014], "sale": [55, 40, 84, 31]}
)
@compare_both(almost=False)
def test_indexing(self, df):
df1 = df.set_index("month")
yield df1
yield df.set_index("month", drop=False)
yield df.set_index("month", append=True)
yield df.set_index(["year", "month"])
yield df.set_index(["year", "month"], drop=False)
yield df.set_index(["year", "month"], append=True)
yield df1.set_index("year", drop=False, append=True)
df2 = df1.copy()
df2.set_index("year", append=True, inplace=True)
yield df2
self.assertRaisesRegex(KeyError, "unknown", lambda: df.set_index("unknown"))
self.assertRaisesRegex(KeyError, "unknown", lambda: df.set_index(["month", "unknown"]))
for d in [df, df1, df2]:
yield d.reset_index()
yield d.reset_index(drop=True)
yield df1.reset_index(level=0)
yield df2.reset_index(level=1)
yield df2.reset_index(level=[1, 0])
yield df1.reset_index(level="month")
yield df2.reset_index(level="year")
yield df2.reset_index(level=["month", "year"])
yield df2.reset_index(level="month", drop=True)
yield df2.reset_index(level=["month", "year"], drop=True)
self.assertRaisesRegex(
IndexError,
"Too many levels: Index has only 1 level, not 3",
lambda: df1.reset_index(level=2),
)
self.assertRaisesRegex(
IndexError,
"Too many levels: Index has only 1 level, not 4",
lambda: df1.reset_index(level=[3, 2]),
)
self.assertRaisesRegex(KeyError, "unknown.*month", lambda: df1.reset_index(level="unknown"))
self.assertRaisesRegex(
KeyError, "Level unknown not found", lambda: df2.reset_index(level="unknown")
)
df3 = df2.copy()
df3.reset_index(inplace=True)
yield df3
yield df1.sale.reset_index()
yield df1.sale.reset_index(level=0)
yield df2.sale.reset_index(level=[1, 0])
yield df1.sale.reset_index(drop=True)
yield df1.sale.reset_index(name="s")
yield df1.sale.reset_index(name="s", drop=True)
s = df1.sale
self.assertRaisesRegex(
TypeError,
"Cannot reset_index inplace on a Series to create a DataFrame",
lambda: s.reset_index(inplace=True),
)
s.reset_index(drop=True, inplace=True)
yield s
yield df1
# multi-index columns
df4 = df.copy()
df4.columns = pd.MultiIndex.from_tuples(
[("cal", "month"), ("cal", "year"), ("num", "sale")]
)
df5 = df4.set_index(("cal", "month"))
yield df5
yield df4.set_index([("cal", "month"), ("num", "sale")])
self.assertRaises(KeyError, lambda: df5.reset_index(level=("cal", "month")))
yield df5.reset_index(level=[("cal", "month")])
# non-string names
df6 = df.copy()
df6.columns = [10.0, 20.0, 30.0]
df7 = df6.set_index(10.0)
yield df7
yield df6.set_index([10.0, 30.0])
yield df7.reset_index(level=10.0)
yield df7.reset_index(level=[10.0])
df8 = df.copy()
df8.columns = pd.MultiIndex.from_tuples([(10, "month"), (10, "year"), (20, "sale")])
df9 = df8.set_index((10, "month"))
yield df9
yield df8.set_index([(10, "month"), (20, "sale")])
yield df9.reset_index(level=[(10, "month")])
def test_from_pandas_with_explicit_index(self):
pdf = self.pdf
df1 = ks.from_pandas(pdf.set_index("month"))
self.assertPandasEqual(df1.to_pandas(), pdf.set_index("month"))
df2 = ks.from_pandas(pdf.set_index(["year", "month"]))
self.assertPandasEqual(df2.to_pandas(), pdf.set_index(["year", "month"]))
def test_limitations(self):
df = self.kdf.set_index("month")
self.assertRaisesRegex(
ValueError,
"Level should be all int or all string.",
lambda: df.reset_index([1, "month"]),
)
class IndexingTest(ReusedSQLTestCase):
@property
def pdf(self):
return pd.DataFrame(
{"a": [1, 2, 3, 4, 5, 6, 7, 8, 9], "b": [4, 5, 6, 3, 2, 1, 0, 0, 0]},
index=[0, 1, 3, 5, 6, 8, 9, 9, 9],
)
@property
def kdf(self):
return ks.from_pandas(self.pdf)
@property
def pdf2(self):
return pd.DataFrame(
{0: [1, 2, 3, 4, 5, 6, 7, 8, 9], 1: [4, 5, 6, 3, 2, 1, 0, 0, 0]},
index=[0, 1, 3, 5, 6, 8, 9, 9, 9],
)
@property
def kdf2(self):
return ks.from_pandas(self.pdf2)
def test_at(self):
pdf = self.pdf
kdf = self.kdf
# Create the equivalent of pdf.loc[3] as a Koalas Series
# This is necessary because .loc[n] does not currently work with Koalas DataFrames (#383)
test_series = ks.Series([3, 6], index=["a", "b"], name="3")
# Assert invalided signatures raise TypeError
with self.assertRaises(TypeError, msg="Use DataFrame.at like .at[row_index, column_name]"):
kdf.at[3]
with self.assertRaises(TypeError, msg="Use DataFrame.at like .at[row_index, column_name]"):
kdf.at["ab"] # 'ab' is of length 2 but str type instead of tuple
with self.assertRaises(TypeError, msg="Use Series.at like .at[column_name]"):
test_series.at[3, "b"]
# Assert .at for DataFrames
self.assertEqual(kdf.at[3, "b"], 6)
self.assertEqual(kdf.at[3, "b"], pdf.at[3, "b"])
self.assert_eq(kdf.at[9, "b"], np.array([0, 0, 0]))
self.assert_eq(kdf.at[9, "b"], pdf.at[9, "b"])
# Assert .at for Series
self.assertEqual(test_series.at["b"], 6)
self.assertEqual(test_series.at["b"], pdf.loc[3].at["b"])
# Assert multi-character indices
self.assertEqual(
ks.Series([0, 1], index=["ab", "cd"]).at["ab"],
pd.Series([0, 1], index=["ab", "cd"]).at["ab"],
)
# Assert invalid column or index names result in a KeyError like with pandas
with self.assertRaises(KeyError, msg="x"):
kdf.at[3, "x"]
with self.assertRaises(KeyError, msg=99):
kdf.at[99, "b"]
with self.assertRaises(ValueError):
kdf.at[(3, 6), "b"]
with self.assertRaises(KeyError):
kdf.at[3, ("x", "b")]
# Assert setting values fails
with self.assertRaises(TypeError):
kdf.at[3, "b"] = 10
# non-string column names
pdf = self.pdf2
kdf = self.kdf2
# Assert .at for DataFrames
self.assertEqual(kdf.at[3, 1], 6)
self.assertEqual(kdf.at[3, 1], pdf.at[3, 1])
self.assert_eq(kdf.at[9, 1], np.array([0, 0, 0]))
self.assert_eq(kdf.at[9, 1], pdf.at[9, 1])
def test_at_multiindex(self):
pdf = self.pdf.set_index("b", append=True)
kdf = self.kdf.set_index("b", append=True)
# TODO: seems like a pandas' bug in pandas>=1.1.0
if LooseVersion(pd.__version__) < LooseVersion("1.1.0"):
self.assert_eq(kdf.at[(3, 6), "a"], pdf.at[(3, 6), "a"])
self.assert_eq(kdf.at[(3,), "a"], pdf.at[(3,), "a"])
self.assert_eq(list(kdf.at[(9, 0), "a"]), list(pdf.at[(9, 0), "a"]))
self.assert_eq(list(kdf.at[(9,), "a"]), list(pdf.at[(9,), "a"]))
else:
self.assert_eq(kdf.at[(3, 6), "a"], 3)
self.assert_eq(kdf.at[(3,), "a"], np.array([3]))
self.assert_eq(list(kdf.at[(9, 0), "a"]), [7, 8, 9])
self.assert_eq(list(kdf.at[(9,), "a"]), [7, 8, 9])
with self.assertRaises(ValueError):
kdf.at[3, "a"]
def test_at_multiindex_columns(self):
arrays = [np.array(["bar", "bar", "baz", "baz"]), np.array(["one", "two", "one", "two"])]
pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.at["B", ("bar", "one")], pdf.at["B", ("bar", "one")])
with self.assertRaises(KeyError):
kdf.at["B", "bar"]
# non-string column names
arrays = [np.array([0, 0, 1, 1]), np.array([1, 2, 1, 2])]
pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.at["B", (0, 1)], pdf.at["B", (0, 1)])
def test_iat(self):
pdf = self.pdf
kdf = self.kdf
# Create the equivalent of pdf.loc[3] as a Koalas Series
# This is necessary because .loc[n] does not currently work with Koalas DataFrames (#383)
test_series = ks.Series([3, 6], index=["a", "b"], name="3")
# Assert invalided signatures raise TypeError
with self.assertRaises(
TypeError,
msg="Use DataFrame.at like .iat[row_interget_position, column_integer_position]",
):
kdf.iat[3]
with self.assertRaises(
ValueError, msg="iAt based indexing on multi-index can only have tuple values"
):
kdf.iat[3, "b"] # 'ab' is of length 2 but str type instead of tuple
with self.assertRaises(TypeError, msg="Use Series.iat like .iat[row_integer_position]"):
test_series.iat[3, "b"]
# Assert .iat for DataFrames
self.assertEqual(kdf.iat[7, 0], 8)
self.assertEqual(kdf.iat[7, 0], pdf.iat[7, 0])
# Assert .iat for Series
self.assertEqual(test_series.iat[1], 6)
self.assertEqual(test_series.iat[1], pdf.loc[3].iat[1])
# Assert invalid column or integer position result in a KeyError like with pandas
with self.assertRaises(KeyError, msg=99):
kdf.iat[0, 99]
with self.assertRaises(KeyError, msg=99):
kdf.iat[99, 0]
with self.assertRaises(ValueError):
kdf.iat[(1, 1), 1]
with self.assertRaises(ValueError):
kdf.iat[1, (1, 1)]
# Assert setting values fails
with self.assertRaises(TypeError):
kdf.iat[4, 1] = 10
def test_iat_multiindex(self):
pdf = self.pdf.set_index("b", append=True)
kdf = self.kdf.set_index("b", append=True)
self.assert_eq(kdf.iat[7, 0], pdf.iat[7, 0])
with self.assertRaises(ValueError):
kdf.iat[3, "a"]
def test_iat_multiindex_columns(self):
arrays = [np.array(["bar", "bar", "baz", "baz"]), np.array(["one", "two", "one", "two"])]
pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.iat[1, 3], pdf.iat[1, 3])
with self.assertRaises(KeyError):
kdf.iat[0, 99]
with self.assertRaises(KeyError):
kdf.iat[99, 0]
def test_loc(self):
kdf = self.kdf
pdf = self.pdf
self.assert_eq(kdf.loc[5:5], pdf.loc[5:5])
self.assert_eq(kdf.loc[3:8], pdf.loc[3:8])
self.assert_eq(kdf.loc[:8], pdf.loc[:8])
self.assert_eq(kdf.loc[3:], pdf.loc[3:])
self.assert_eq(kdf.loc[[5]], pdf.loc[[5]])
self.assert_eq(kdf.loc[:], pdf.loc[:])
# TODO?: self.assert_eq(kdf.loc[[3, 4, 1, 8]], pdf.loc[[3, 4, 1, 8]])
# TODO?: self.assert_eq(kdf.loc[[3, 4, 1, 9]], pdf.loc[[3, 4, 1, 9]])
# TODO?: self.assert_eq(kdf.loc[np.array([3, 4, 1, 9])], pdf.loc[np.array([3, 4, 1, 9])])
self.assert_eq(kdf.a.loc[5:5], pdf.a.loc[5:5])
self.assert_eq(kdf.a.loc[3:8], pdf.a.loc[3:8])
self.assert_eq(kdf.a.loc[:8], pdf.a.loc[:8])
self.assert_eq(kdf.a.loc[3:], pdf.a.loc[3:])
self.assert_eq(kdf.a.loc[[5]], pdf.a.loc[[5]])
# TODO?: self.assert_eq(kdf.a.loc[[3, 4, 1, 8]], pdf.a.loc[[3, 4, 1, 8]])
# TODO?: self.assert_eq(kdf.a.loc[[3, 4, 1, 9]], pdf.a.loc[[3, 4, 1, 9]])
# TODO?: self.assert_eq(kdf.a.loc[np.array([3, 4, 1, 9])],
# pdf.a.loc[np.array([3, 4, 1, 9])])
self.assert_eq(kdf.a.loc[[]], pdf.a.loc[[]])
self.assert_eq(kdf.a.loc[np.array([])], pdf.a.loc[np.array([])])
self.assert_eq(kdf.loc[1000:], pdf.loc[1000:])
self.assert_eq(kdf.loc[-2000:-1000], pdf.loc[-2000:-1000])
self.assert_eq(kdf.loc[5], pdf.loc[5])
self.assert_eq(kdf.loc[9], pdf.loc[9])
self.assert_eq(kdf.a.loc[5], pdf.a.loc[5])
self.assert_eq(kdf.a.loc[9], pdf.a.loc[9])
self.assertRaises(KeyError, lambda: kdf.loc[10])
self.assertRaises(KeyError, lambda: kdf.a.loc[10])
# monotonically increasing index test
pdf = pd.DataFrame({"a": [1, 2, 3, 4, 5, 6, 7, 8, 9]}, index=[0, 1, 1, 2, 2, 2, 4, 5, 6])
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc[:2], pdf.loc[:2])
self.assert_eq(kdf.loc[:3], pdf.loc[:3])
self.assert_eq(kdf.loc[3:], pdf.loc[3:])
self.assert_eq(kdf.loc[4:], pdf.loc[4:])
self.assert_eq(kdf.loc[3:2], pdf.loc[3:2])
self.assert_eq(kdf.loc[-1:2], pdf.loc[-1:2])
self.assert_eq(kdf.loc[3:10], pdf.loc[3:10])
# monotonically decreasing index test
pdf = pd.DataFrame({"a": [1, 2, 3, 4, 5, 6, 7, 8, 9]}, index=[6, 5, 5, 4, 4, 4, 2, 1, 0])
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc[:4], pdf.loc[:4])
self.assert_eq(kdf.loc[:3], pdf.loc[:3])
self.assert_eq(kdf.loc[3:], pdf.loc[3:])
self.assert_eq(kdf.loc[2:], pdf.loc[2:])
self.assert_eq(kdf.loc[2:3], pdf.loc[2:3])
self.assert_eq(kdf.loc[2:-1], pdf.loc[2:-1])
self.assert_eq(kdf.loc[10:3], pdf.loc[10:3])
# test when type of key is string and given value is not included in key
pdf = pd.DataFrame({"a": [1, 2, 3]}, index=["a", "b", "d"])
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc["a":"z"], pdf.loc["a":"z"])
# KeyError when index is not monotonic increasing or decreasing
# and specified values don't exist in index
kdf = ks.DataFrame([[1, 2], [4, 5], [7, 8]], index=["cobra", "viper", "sidewinder"])
self.assertRaises(KeyError, lambda: kdf.loc["cobra":"koalas"])
self.assertRaises(KeyError, lambda: kdf.loc["koalas":"viper"])
kdf = ks.DataFrame([[1, 2], [4, 5], [7, 8]], index=[10, 30, 20])
self.assertRaises(KeyError, lambda: kdf.loc[0:30])
self.assertRaises(KeyError, lambda: kdf.loc[10:100])
def test_loc_non_informative_index(self):
pdf = pd.DataFrame({"x": [1, 2, 3, 4]}, index=[10, 20, 30, 40])
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc[20:30], pdf.loc[20:30])
pdf = pd.DataFrame({"x": [1, 2, 3, 4]}, index=[10, 20, 20, 40])
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc[20:20], pdf.loc[20:20])
def test_loc_with_series(self):
kdf = self.kdf
pdf = self.pdf
self.assert_eq(kdf.loc[kdf.a % 2 == 0], pdf.loc[pdf.a % 2 == 0])
self.assert_eq(kdf.loc[kdf.a % 2 == 0, "a"], pdf.loc[pdf.a % 2 == 0, "a"])
self.assert_eq(kdf.loc[kdf.a % 2 == 0, ["a"]], pdf.loc[pdf.a % 2 == 0, ["a"]])
self.assert_eq(kdf.a.loc[kdf.a % 2 == 0], pdf.a.loc[pdf.a % 2 == 0])
self.assert_eq(kdf.loc[kdf.copy().a % 2 == 0], pdf.loc[pdf.copy().a % 2 == 0])
self.assert_eq(kdf.loc[kdf.copy().a % 2 == 0, "a"], pdf.loc[pdf.copy().a % 2 == 0, "a"])
self.assert_eq(kdf.loc[kdf.copy().a % 2 == 0, ["a"]], pdf.loc[pdf.copy().a % 2 == 0, ["a"]])
self.assert_eq(kdf.a.loc[kdf.copy().a % 2 == 0], pdf.a.loc[pdf.copy().a % 2 == 0])
def test_loc_noindex(self):
kdf = self.kdf
kdf = kdf.reset_index()
pdf = self.pdf
pdf = pdf.reset_index()
self.assert_eq(kdf[["a"]], pdf[["a"]])
self.assert_eq(kdf.loc[:], pdf.loc[:])
self.assert_eq(kdf.loc[5:5], pdf.loc[5:5])
def test_loc_multiindex(self):
kdf = self.kdf
kdf = kdf.set_index("b", append=True)
pdf = self.pdf
pdf = pdf.set_index("b", append=True)
self.assert_eq(kdf.loc[:], pdf.loc[:])
self.assert_eq(kdf.loc[5:5], pdf.loc[5:5])
self.assert_eq(kdf.loc[5:9], pdf.loc[5:9])
self.assert_eq(kdf.loc[5], pdf.loc[5])
self.assert_eq(kdf.loc[9], pdf.loc[9])
# TODO: self.assert_eq(kdf.loc[(5, 3)], pdf.loc[(5, 3)])
# TODO: self.assert_eq(kdf.loc[(9, 0)], pdf.loc[(9, 0)])
self.assert_eq(kdf.a.loc[5], pdf.a.loc[5])
self.assert_eq(kdf.a.loc[9], pdf.a.loc[9])
self.assertTrue((kdf.a.loc[(5, 3)] == pdf.a.loc[(5, 3)]).all())
self.assert_eq(kdf.a.loc[(9, 0)], pdf.a.loc[(9, 0)])
# monotonically increasing index test
pdf = pd.DataFrame(
{"a": [1, 2, 3, 4, 5]},
index=pd.MultiIndex.from_tuples(
[("x", "a"), ("x", "b"), ("y", "c"), ("y", "d"), ("z", "e")]
),
)
kdf = ks.from_pandas(pdf)
for rows_sel in [
slice(None),
slice("y", None),
slice(None, "y"),
slice(("x", "b"), None),
slice(None, ("y", "c")),
slice(("x", "b"), ("y", "c")),
slice("x", ("y", "c")),
slice(("x", "b"), "y"),
]:
with self.subTest("monotonically increasing", rows_sel=rows_sel):
self.assert_eq(kdf.loc[rows_sel], pdf.loc[rows_sel])
self.assert_eq(kdf.a.loc[rows_sel], pdf.a.loc[rows_sel])
# monotonically increasing first index test
pdf = pd.DataFrame(
{"a": [1, 2, 3, 4, 5]},
index=pd.MultiIndex.from_tuples(
[("x", "a"), ("x", "b"), ("y", "c"), ("y", "a"), ("z", "e")]
),
)
kdf = ks.from_pandas(pdf)
for rows_sel in [
slice(None),
slice("y", None),
slice(None, "y"),
]:
with self.subTest("monotonically increasing first index", rows_sel=rows_sel):
self.assert_eq(kdf.loc[rows_sel], pdf.loc[rows_sel])
self.assert_eq(kdf.a.loc[rows_sel], pdf.a.loc[rows_sel])
for rows_sel in [
slice(("x", "b"), None),
slice(None, ("y", "c")),
slice(("x", "b"), ("y", "c")),
slice("x", ("y", "c")),
slice(("x", "b"), "y"),
]:
with self.subTest("monotonically increasing first index", rows_sel=rows_sel):
self.assertRaises(KeyError, lambda: kdf.loc[rows_sel])
self.assertRaises(KeyError, lambda: kdf.a.loc[rows_sel])
# not monotonically increasing index test
pdf = pd.DataFrame(
{"a": [1, 2, 3, 4, 5]},
index=pd.MultiIndex.from_tuples(
[("z", "e"), ("y", "d"), ("y", "c"), ("x", "b"), ("x", "a")]
),
)
kdf = ks.from_pandas(pdf)
for rows_sel in [
slice("y", None),
slice(None, "y"),
slice(("x", "b"), None),
slice(None, ("y", "c")),
slice(("x", "b"), ("y", "c")),
slice("x", ("y", "c")),
slice(("x", "b"), "y"),
]:
with self.subTest("monotonically decreasing", rows_sel=rows_sel):
self.assertRaises(KeyError, lambda: kdf.loc[rows_sel])
self.assertRaises(KeyError, lambda: kdf.a.loc[rows_sel])
def test_loc2d_multiindex(self):
kdf = self.kdf
kdf = kdf.set_index("b", append=True)
pdf = self.pdf
pdf = pdf.set_index("b", append=True)
self.assert_eq(kdf.loc[:, :], pdf.loc[:, :])
self.assert_eq(kdf.loc[:, "a"], pdf.loc[:, "a"])
self.assert_eq(kdf.loc[5:5, "a"], pdf.loc[5:5, "a"])
self.assert_eq(kdf.loc[:, "a":"a"], pdf.loc[:, "a":"a"])
self.assert_eq(kdf.loc[:, "a":"c"], pdf.loc[:, "a":"c"])
self.assert_eq(kdf.loc[:, "b":"c"], pdf.loc[:, "b":"c"])
def test_loc2d(self):
kdf = self.kdf
pdf = self.pdf
# index indexer is always regarded as slice for duplicated values
self.assert_eq(kdf.loc[5:5, "a"], pdf.loc[5:5, "a"])
self.assert_eq(kdf.loc[[5], "a"], pdf.loc[[5], "a"])
self.assert_eq(kdf.loc[5:5, ["a"]], pdf.loc[5:5, ["a"]])
self.assert_eq(kdf.loc[[5], ["a"]], pdf.loc[[5], ["a"]])
self.assert_eq(kdf.loc[:, :], pdf.loc[:, :])
self.assert_eq(kdf.loc[3:8, "a"], pdf.loc[3:8, "a"])
self.assert_eq(kdf.loc[:8, "a"], pdf.loc[:8, "a"])
self.assert_eq(kdf.loc[3:, "a"], pdf.loc[3:, "a"])
self.assert_eq(kdf.loc[[8], "a"], pdf.loc[[8], "a"])
self.assert_eq(kdf.loc[3:8, ["a"]], pdf.loc[3:8, ["a"]])
self.assert_eq(kdf.loc[:8, ["a"]], pdf.loc[:8, ["a"]])
self.assert_eq(kdf.loc[3:, ["a"]], pdf.loc[3:, ["a"]])
# TODO?: self.assert_eq(kdf.loc[[3, 4, 3], ['a']], pdf.loc[[3, 4, 3], ['a']])
self.assertRaises(SparkPandasIndexingError, lambda: kdf.loc[3, 3, 3])
self.assertRaises(SparkPandasIndexingError, lambda: kdf.a.loc[3, 3])
self.assertRaises(SparkPandasIndexingError, lambda: kdf.a.loc[3:, 3])
self.assertRaises(SparkPandasIndexingError, lambda: kdf.a.loc[kdf.a % 2 == 0, 3])
self.assert_eq(kdf.loc[5, "a"], pdf.loc[5, "a"])
self.assert_eq(kdf.loc[9, "a"], pdf.loc[9, "a"])
self.assert_eq(kdf.loc[5, ["a"]], pdf.loc[5, ["a"]])
self.assert_eq(kdf.loc[9, ["a"]], pdf.loc[9, ["a"]])
self.assert_eq(kdf.loc[:, "a":"a"], pdf.loc[:, "a":"a"])
self.assert_eq(kdf.loc[:, "a":"d"], pdf.loc[:, "a":"d"])
self.assert_eq(kdf.loc[:, "c":"d"], pdf.loc[:, "c":"d"])
# bool list-like column select
bool_list = [True, False]
self.assert_eq(kdf.loc[:, bool_list], pdf.loc[:, bool_list])
self.assert_eq(kdf.loc[:, np.array(bool_list)], pdf.loc[:, np.array(bool_list)])
pser = pd.Series(bool_list, index=pdf.columns)
self.assert_eq(kdf.loc[:, pser], pdf.loc[:, pser])
pser = pd.Series(list(reversed(bool_list)), index=list(reversed(pdf.columns)))
self.assert_eq(kdf.loc[:, pser], pdf.loc[:, pser])
self.assertRaises(IndexError, lambda: kdf.loc[:, bool_list[:-1]])
self.assertRaises(IndexError, lambda: kdf.loc[:, np.array(bool_list + [True])])
self.assertRaises(SparkPandasIndexingError, lambda: kdf.loc[:, pd.Series(bool_list)])
# non-string column names
kdf = self.kdf2
pdf = self.pdf2
self.assert_eq(kdf.loc[5:5, 0], pdf.loc[5:5, 0])
self.assert_eq(kdf.loc[5:5, [0]], pdf.loc[5:5, [0]])
self.assert_eq(kdf.loc[3:8, 0], pdf.loc[3:8, 0])
self.assert_eq(kdf.loc[3:8, [0]], pdf.loc[3:8, [0]])
self.assert_eq(kdf.loc[:, 0:0], pdf.loc[:, 0:0])
self.assert_eq(kdf.loc[:, 0:3], pdf.loc[:, 0:3])
self.assert_eq(kdf.loc[:, 2:3], pdf.loc[:, 2:3])
def test_loc2d_multiindex_columns(self):
arrays = [np.array(["bar", "bar", "baz", "baz"]), np.array(["one", "two", "one", "two"])]
pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc["B":"B", "bar"], pdf.loc["B":"B", "bar"])
self.assert_eq(kdf.loc["B":"B", ["bar"]], pdf.loc["B":"B", ["bar"]])
self.assert_eq(kdf.loc[:, "bar":"bar"], pdf.loc[:, "bar":"bar"])
self.assert_eq(kdf.loc[:, "bar":("baz", "one")], pdf.loc[:, "bar":("baz", "one")])
self.assert_eq(
kdf.loc[:, ("bar", "two"):("baz", "one")], pdf.loc[:, ("bar", "two"):("baz", "one")]
)
self.assert_eq(kdf.loc[:, ("bar", "two"):"bar"], pdf.loc[:, ("bar", "two"):"bar"])
self.assert_eq(kdf.loc[:, "a":"bax"], pdf.loc[:, "a":"bax"])
self.assert_eq(
kdf.loc[:, ("bar", "x"):("baz", "a")],
pdf.loc[:, ("bar", "x"):("baz", "a")],
almost=True,
)
pdf = pd.DataFrame(
np.random.randn(3, 4),
index=["A", "B", "C"],
columns=pd.MultiIndex.from_tuples(
[("bar", "two"), ("bar", "one"), ("baz", "one"), ("baz", "two")]
),
)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc[:, "bar":"baz"], pdf.loc[:, "bar":"baz"])
self.assertRaises(KeyError, lambda: kdf.loc[:, "bar":("baz", "one")])
self.assertRaises(KeyError, lambda: kdf.loc[:, ("bar", "two"):"bar"])
# bool list-like column select
bool_list = [True, False, True, False]
self.assert_eq(kdf.loc[:, bool_list], pdf.loc[:, bool_list])
self.assert_eq(kdf.loc[:, np.array(bool_list)], pdf.loc[:, np.array(bool_list)])
pser = pd.Series(bool_list, index=pdf.columns)
self.assert_eq(kdf.loc[:, pser], pdf.loc[:, pser])
pser = pd.Series(list(reversed(bool_list)), index=list(reversed(pdf.columns)))
self.assert_eq(kdf.loc[:, pser], pdf.loc[:, pser])
# non-string column names
arrays = [np.array([0, 0, 1, 1]), np.array([1, 2, 1, 2])]
pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc["B":"B", 0], pdf.loc["B":"B", 0])
self.assert_eq(kdf.loc["B":"B", [0]], pdf.loc["B":"B", [0]])
self.assert_eq(kdf.loc[:, 0:0], pdf.loc[:, 0:0])
self.assert_eq(kdf.loc[:, 0:(1, 1)], pdf.loc[:, 0:(1, 1)])
self.assert_eq(kdf.loc[:, (0, 2):(1, 1)], pdf.loc[:, (0, 2):(1, 1)])
self.assert_eq(kdf.loc[:, (0, 2):0], pdf.loc[:, (0, 2):0])
self.assert_eq(kdf.loc[:, -1:2], pdf.loc[:, -1:2])
def test_loc2d_with_known_divisions(self):
pdf = pd.DataFrame(
np.random.randn(20, 5), index=list("abcdefghijklmnopqrst"), columns=list("ABCDE")
)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc[["a"], "A"], pdf.loc[["a"], "A"])
self.assert_eq(kdf.loc[["a"], ["A"]], pdf.loc[["a"], ["A"]])
self.assert_eq(kdf.loc["a":"o", "A"], pdf.loc["a":"o", "A"])
self.assert_eq(kdf.loc["a":"o", ["A"]], pdf.loc["a":"o", ["A"]])
self.assert_eq(kdf.loc[["n"], ["A"]], pdf.loc[["n"], ["A"]])
self.assert_eq(kdf.loc[["a", "c", "n"], ["A"]], pdf.loc[["a", "c", "n"], ["A"]])
# TODO?: self.assert_eq(kdf.loc[['t', 'b'], ['A']], pdf.loc[['t', 'b'], ['A']])
# TODO?: self.assert_eq(kdf.loc[['r', 'r', 'c', 'g', 'h'], ['A']],
# TODO?: pdf.loc[['r', 'r', 'c', 'g', 'h'], ['A']])
@unittest.skip("TODO: should handle duplicated columns properly")
def test_loc2d_duplicated_columns(self):
pdf = pd.DataFrame(
np.random.randn(20, 5), index=list("abcdefghijklmnopqrst"), columns=list("AABCD")
)
kdf = ks.from_pandas(pdf)
# TODO?: self.assert_eq(kdf.loc[['a'], 'A'], pdf.loc[['a'], 'A'])
# TODO?: self.assert_eq(kdf.loc[['a'], ['A']], pdf.loc[['a'], ['A']])
self.assert_eq(kdf.loc[["j"], "B"], pdf.loc[["j"], "B"])
self.assert_eq(kdf.loc[["j"], ["B"]], pdf.loc[["j"], ["B"]])
# TODO?: self.assert_eq(kdf.loc['a':'o', 'A'], pdf.loc['a':'o', 'A'])
# TODO?: self.assert_eq(kdf.loc['a':'o', ['A']], pdf.loc['a':'o', ['A']])
self.assert_eq(kdf.loc["j":"q", "B"], pdf.loc["j":"q", "B"])
self.assert_eq(kdf.loc["j":"q", ["B"]], pdf.loc["j":"q", ["B"]])
# TODO?: self.assert_eq(kdf.loc['a':'o', 'B':'D'], pdf.loc['a':'o', 'B':'D'])
# TODO?: self.assert_eq(kdf.loc['a':'o', 'B':'D'], pdf.loc['a':'o', 'B':'D'])
# TODO?: self.assert_eq(kdf.loc['j':'q', 'B':'A'], pdf.loc['j':'q', 'B':'A'])
# TODO?: self.assert_eq(kdf.loc['j':'q', 'B':'A'], pdf.loc['j':'q', 'B':'A'])
self.assert_eq(kdf.loc[kdf.B > 0, "B"], pdf.loc[pdf.B > 0, "B"])
# TODO?: self.assert_eq(kdf.loc[kdf.B > 0, ['A', 'C']], pdf.loc[pdf.B > 0, ['A', 'C']])
def test_getitem(self):
pdf = pd.DataFrame(
{
"A": [1, 2, 3, 4, 5, 6, 7, 8, 9],
"B": [9, 8, 7, 6, 5, 4, 3, 2, 1],
"C": [True, False, True] * 3,
},
columns=list("ABC"),
)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf["A"], pdf["A"])
self.assert_eq(kdf[["A", "B"]], pdf[["A", "B"]])
self.assert_eq(kdf[kdf.C], pdf[pdf.C])
self.assertRaises(KeyError, lambda: kdf["X"])
self.assertRaises(KeyError, lambda: kdf[["A", "X"]])
self.assertRaises(AttributeError, lambda: kdf.X)
# not str/unicode
# TODO?: pdf = pd.DataFrame(np.random.randn(10, 5))
# TODO?: kdf = ks.from_pandas(pdf)
# TODO?: self.assert_eq(kdf[0], pdf[0])
# TODO?: self.assert_eq(kdf[[1, 2]], pdf[[1, 2]])
# TODO?: self.assertRaises(KeyError, lambda: pdf[8])
# TODO?: self.assertRaises(KeyError, lambda: pdf[[1, 8]])
# non-string column names
pdf = pd.DataFrame(
{
10: [1, 2, 3, 4, 5, 6, 7, 8, 9],
20: [9, 8, 7, 6, 5, 4, 3, 2, 1],
30: [True, False, True] * 3,
}
)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf[10], pdf[10])
self.assert_eq(kdf[[10, 20]], pdf[[10, 20]])
def test_getitem_slice(self):
pdf = pd.DataFrame(
{
"A": [1, 2, 3, 4, 5, 6, 7, 8, 9],
"B": [9, 8, 7, 6, 5, 4, 3, 2, 1],
"C": [True, False, True] * 3,
},
index=list("abcdefghi"),
)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf["a":"e"], pdf["a":"e"])
self.assert_eq(kdf["a":"b"], pdf["a":"b"])
self.assert_eq(kdf["f":], pdf["f":])
def test_loc_on_numpy_datetimes(self):
pdf = pd.DataFrame(
{"x": [1, 2, 3]}, index=list(map(np.datetime64, ["2014", "2015", "2016"]))
)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc["2014":"2015"], pdf.loc["2014":"2015"])
def test_loc_on_pandas_datetimes(self):
pdf = pd.DataFrame(
{"x": [1, 2, 3]}, index=list(map(pd.Timestamp, ["2014", "2015", "2016"]))
)
kdf = ks.from_pandas(pdf)
self.assert_eq(kdf.loc["2014":"2015"], pdf.loc["2014":"2015"])
@unittest.skip("TODO?: the behavior of slice for datetime")
def test_loc_datetime_no_freq(self):
datetime_index = pd.date_range("2016-01-01", "2016-01-31", freq="12h")
datetime_index.freq = None # FORGET FREQUENCY
pdf = pd.DataFrame({"num": range(len(datetime_index))}, index=datetime_index)
kdf = ks.from_pandas(pdf)
slice_ = slice("2016-01-03", "2016-01-05")
result = kdf.loc[slice_, :]
expected = pdf.loc[slice_, :]
self.assert_eq(result, expected)
@unittest.skip("TODO?: the behavior of slice for datetime")
def test_loc_timestamp_str(self):
pdf = pd.DataFrame(
{"A": np.random.randn(100), "B": np.random.randn(100)},
index=pd.date_range("2011-01-01", freq="H", periods=100),
)
kdf = ks.from_pandas(pdf)
# partial string slice
# TODO?: self.assert_eq(pdf.loc['2011-01-02'],
# TODO?: kdf.loc['2011-01-02'])
self.assert_eq(pdf.loc["2011-01-02":"2011-01-05"], kdf.loc["2011-01-02":"2011-01-05"])
# series
# TODO?: self.assert_eq(pdf.A.loc['2011-01-02'],
# TODO?: kdf.A.loc['2011-01-02'])
self.assert_eq(pdf.A.loc["2011-01-02":"2011-01-05"], kdf.A.loc["2011-01-02":"2011-01-05"])
pdf = pd.DataFrame(
{"A": np.random.randn(100), "B": np.random.randn(100)},
index=pd.date_range("2011-01-01", freq="M", periods=100),
)
kdf = ks.from_pandas(pdf)
# TODO?: self.assert_eq(pdf.loc['2011-01'], kdf.loc['2011-01'])
# TODO?: self.assert_eq(pdf.loc['2011'], kdf.loc['2011'])
self.assert_eq(pdf.loc["2011-01":"2012-05"], kdf.loc["2011-01":"2012-05"])
self.assert_eq(pdf.loc["2011":"2015"], kdf.loc["2011":"2015"])
# series
# TODO?: self.assert_eq(pdf.B.loc['2011-01'], kdf.B.loc['2011-01'])
# TODO?: self.assert_eq(pdf.B.loc['2011'], kdf.B.loc['2011'])
self.assert_eq(pdf.B.loc["2011-01":"2012-05"], kdf.B.loc["2011-01":"2012-05"])
self.assert_eq(pdf.B.loc["2011":"2015"], kdf.B.loc["2011":"2015"])
@unittest.skip("TODO?: the behavior of slice for datetime")
def test_getitem_timestamp_str(self):
pdf = pd.DataFrame(
{"A": np.random.randn(100), "B": np.random.randn(100)},
index=pd.date_range("2011-01-01", freq="H", periods=100),
)
kdf = ks.from_pandas(pdf)
# partial string slice
# TODO?: self.assert_eq(pdf['2011-01-02'],
# TODO?: kdf['2011-01-02'])
self.assert_eq(pdf["2011-01-02":"2011-01-05"], kdf["2011-01-02":"2011-01-05"])
pdf = pd.DataFrame(
{"A": np.random.randn(100), "B": np.random.randn(100)},
index=pd.date_range("2011-01-01", freq="M", periods=100),
)
kdf = ks.from_pandas(pdf)
# TODO?: self.assert_eq(pdf['2011-01'], kdf['2011-01'])
# TODO?: self.assert_eq(pdf['2011'], kdf['2011'])
self.assert_eq(pdf["2011-01":"2012-05"], kdf["2011-01":"2012-05"])
self.assert_eq(pdf["2011":"2015"], kdf["2011":"2015"])
@unittest.skip("TODO?: period index can't convert to DataFrame correctly")
def test_getitem_period_str(self):
pdf = pd.DataFrame(
{"A": np.random.randn(100), "B": np.random.randn(100)},
index=pd.period_range("2011-01-01", freq="H", periods=100),
)
kdf = ks.from_pandas(pdf)
# partial string slice
# TODO?: self.assert_eq(pdf['2011-01-02'],
# TODO?: kdf['2011-01-02'])
self.assert_eq(pdf["2011-01-02":"2011-01-05"], kdf["2011-01-02":"2011-01-05"])
pdf = pd.DataFrame(
{"A": | np.random.randn(100) | numpy.random.randn |
"""Logger application"""
from __future__ import annotations
import csv
import json
import queue
import sys
import threading
import time
import traceback
import warnings
from datetime import datetime
from typing import Any, Optional
from serial.threaded import ReaderThread #type:ignore
from flask import render_template, request, Flask, Response
from waitress import serve #type:ignore
import numpy as np
from config import loadnames
import lib
SAMPLE_DATA_FILENAME = 'data_sample.csv'
RAW_DATA_FILENAME = 'data_raw.csv'
HOURLY_DATA_FILENAME = 'data_hourly.csv'
# there's no default here, the default is in the arduino code
current_config = lib.Conf()
app = Flask(__name__)
rng = np.random.default_rng() #type:ignore
raw_queue: queue.SimpleQueue[bytes] = queue.SimpleQueue()
randx = rng.integers(1023, size=100)
randy = rng.integers(1023, size=100)
latest_va = {'load1': lib.VA('load1', 5000, 1000, randx, randy),
'load2': lib.VA('load2', 5000, 1000, randx, randy),
'load3': lib.VA('load3', 5000, 1000, randx, randy),
'load4': lib.VA('load4', 5000, 1000, randx, randy),
'load5': lib.VA('load5', 5000, 1000, randx, randy),
'load6': lib.VA('load6', 5000, 1000, randx, randy),
'load7': lib.VA('load7', 5000, 1000, randx, randy),
'load8': lib.VA('load8', 5000, 1000, randx, randy),}
def va_updater(volts_amps: lib.VA) -> None:
"""Callback for updating VA"""
latest_va[volts_amps.load] = volts_amps
TRIM_FREQ = 200 # trim every N rows
TRIM_SIZE = 10000 # size of raw file to retain
def make_sample_line(now_s: str, samples: lib.VA) -> str:
"""sample data is for debugging"""
sample_v_mean: float = | np.mean(samples.volts) | numpy.mean |
from collections import OrderedDict
import numpy as np
import collections
from copy import deepcopy
import random
import robosuite.utils.transform_utils as T
from robosuite.utils.mjcf_utils import CustomMaterial, array_to_string, find_elements, new_site
from robosuite.utils.mjcf_utils import CustomMaterial
from robosuite.environments.manipulation.single_arm_env import SingleArmEnv
from robosuite.models.arenas import TableArena
from robosuite.models.objects import BoxObject, CylinderObject, PlateWithHoleObject
from robosuite.models.tasks import ManipulationTask
from robosuite.utils.placement_samplers import UniformRandomSampler
from robosuite.utils.observables import Observable, sensor
class Lift(SingleArmEnv):
"""
This class corresponds to the lifting task for a single robot arm.
Args:
robots (str or list of str): Specification for specific robot arm(s) to be instantiated within this env
(e.g: "Sawyer" would generate one arm; ["Panda", "Panda", "Sawyer"] would generate three robot arms)
Note: Must be a single single-arm robot!
env_configuration (str): Specifies how to position the robots within the environment (default is "default").
For most single arm environments, this argument has no impact on the robot setup.
controller_configs (str or list of dict): If set, contains relevant controller parameters for creating a
custom controller. Else, uses the default controller for this specific task. Should either be single
dict if same controller is to be used for all robots or else it should be a list of the same length as
"robots" param
gripper_types (str or list of str): type of gripper, used to instantiate
gripper models from gripper factory. Default is "default", which is the default grippers(s) associated
with the robot(s) the 'robots' specification. None removes the gripper, and any other (valid) model
overrides the default gripper. Should either be single str if same gripper type is to be used for all
robots or else it should be a list of the same length as "robots" param
initialization_noise (dict or list of dict): Dict containing the initialization noise parameters.
The expected keys and corresponding value types are specified below:
:`'magnitude'`: The scale factor of uni-variate random noise applied to each of a robot's given initial
joint positions. Setting this value to `None` or 0.0 results in no noise being applied.
If "gaussian" type of noise is applied then this magnitude scales the standard deviation applied,
If "uniform" type of noise is applied then this magnitude sets the bounds of the sampling range
:`'type'`: Type of noise to apply. Can either specify "gaussian" or "uniform"
Should either be single dict if same noise value is to be used for all robots or else it should be a
list of the same length as "robots" param
:Note: Specifying "default" will automatically use the default noise settings.
Specifying None will automatically create the required dict with "magnitude" set to 0.0.
table_full_size (3-tuple): x, y, and z dimensions of the table.
table_friction (3-tuple): the three mujoco friction parameters for
the table.
use_camera_obs (bool): if True, every observation includes rendered image(s)
use_object_obs (bool): if True, include object (cube) information in
the observation.
reward_scale (None or float): Scales the normalized reward function by the amount specified.
If None, environment reward remains unnormalized
reward_shaping (bool): if True, use dense rewards.
placement_initializer (ObjectPositionSampler): if provided, will
be used to place objects on every reset, else a UniformRandomSampler
is used by default.
has_renderer (bool): If true, render the simulation state in
a viewer instead of headless mode.
has_offscreen_renderer (bool): True if using off-screen rendering
render_camera (str): Name of camera to render if `has_renderer` is True. Setting this value to 'None'
will result in the default angle being applied, which is useful as it can be dragged / panned by
the user using the mouse
render_collision_mesh (bool): True if rendering collision meshes in camera. False otherwise.
render_visual_mesh (bool): True if rendering visual meshes in camera. False otherwise.
render_gpu_device_id (int): corresponds to the GPU device id to use for offscreen rendering.
Defaults to -1, in which case the device will be inferred from environment variables
(GPUS or CUDA_VISIBLE_DEVICES).
control_freq (float): how many control signals to receive in every second. This sets the amount of
simulation time that passes between every action input.
horizon (int): Every episode lasts for exactly @horizon timesteps.
ignore_done (bool): True if never terminating the environment (ignore @horizon).
hard_reset (bool): If True, re-loads model, sim, and render object upon a reset call, else,
only calls sim.reset and resets all robosuite-internal variables
camera_names (str or list of str): name of camera to be rendered. Should either be single str if
same name is to be used for all cameras' rendering or else it should be a list of cameras to render.
:Note: At least one camera must be specified if @use_camera_obs is True.
:Note: To render all robots' cameras of a certain type (e.g.: "robotview" or "eye_in_hand"), use the
convention "all-{name}" (e.g.: "all-robotview") to automatically render all camera images from each
robot's camera list).
camera_heights (int or list of int): height of camera frame. Should either be single int if
same height is to be used for all cameras' frames or else it should be a list of the same length as
"camera names" param.
camera_widths (int or list of int): width of camera frame. Should either be single int if
same width is to be used for all cameras' frames or else it should be a list of the same length as
"camera names" param.
camera_depths (bool or list of bool): True if rendering RGB-D, and RGB otherwise. Should either be single
bool if same depth setting is to be used for all cameras or else it should be a list of the same length as
"camera names" param.
Raises:
AssertionError: [Invalid number of robots specified]
"""
def __init__(
self,
robots,
env_configuration="default",
controller_configs=None,
gripper_types="default",
initialization_noise="default",
table_full_size=(0.8, 0.8, 0.05),
table_friction=(1., 5e-3, 1e-4),
use_camera_obs=True,
use_object_obs=True,
reward_scale=1.0,
reward_shaping=False,
placement_initializer=None,
has_renderer=False,
has_offscreen_renderer=True,
render_camera="frontview",
render_collision_mesh=False,
render_visual_mesh=True,
render_gpu_device_id=-1,
control_freq=20,
horizon=1000,
ignore_done=False,
hard_reset=True,
camera_names="agentview",
camera_heights=256,
camera_widths=256,
camera_depths=False,
num_via_point=0,
dist_error=0.002,
angle_error=0,
tanh_value=2.0,
r_reach_value=0.94,
error_type='circle',
control_spec=36,
peg_radius=(0.0025, 0.0025), # (0.00125, 0.00125)
peg_length=0.12,
):
#min jerk param:
self.num_via_point = num_via_point
# settings for table top
self.via_point = OrderedDict()
self.table_full_size = table_full_size
self.table_friction = table_friction
self.table_offset = np.array((0, 0, 0.8))
# Save peg specs
self.peg_radius = peg_radius
self.peg_length = peg_length
self.dist_error = dist_error
self.angle_error = angle_error
# reward configuration
self.reward_scale = reward_scale
self.reward_shaping = reward_shaping
# whether to use ground-truth object states
self.use_object_obs = use_object_obs
# object placement initializer
self.placement_initializer = placement_initializer
super().__init__(
robots=robots,
env_configuration=env_configuration,
controller_configs=controller_configs,
mount_types="default",
gripper_types=gripper_types,
initialization_noise=initialization_noise,
use_camera_obs=use_camera_obs,
has_renderer=has_renderer,
has_offscreen_renderer=has_offscreen_renderer,
render_camera=render_camera,
render_collision_mesh=render_collision_mesh,
render_visual_mesh=render_visual_mesh,
render_gpu_device_id=render_gpu_device_id,
control_freq=control_freq,
horizon=horizon,
ignore_done=ignore_done,
hard_reset=hard_reset,
camera_names=camera_names,
camera_heights=camera_heights,
camera_widths=camera_widths,
camera_depths=camera_depths,
dist_error=dist_error,
tanh_value=tanh_value,
r_reach_value=r_reach_value,
error_type=error_type,
control_spec=control_spec,
)
def reward(self, action=None):
"""
Reward function for the task.
Sparse un-normalized reward:
- a discrete reward of 100.0 is provided if the peg is inside the plate's hole
- Note that we enforce that it's inside at an appropriate angle (cos(theta) > 0.95).
Un-normalized summed components if using reward shaping:
- ????
Note that the final reward is normalized and scaled by reward_scale / 5.0 as
well so that the max score is equal to reward_scale
"""
# TODO - reward(self, action=None) - change this function
reward = 0
time_factor = (self.horizon - self.timestep) / self.horizon
# Right location and angle
if self._check_success() and self.num_via_point == 1:
# reward = self.horizon * time_factor
self.success += 1
if self.success == 2:
S = 1
return reward
# use a shaping reward
if self.reward_shaping:
# Grab relevant values
t, d, cos = self._compute_orientation()
# Reach a terminal state as quickly as possible
# reaching reward
reward += self.r_reach * 5 * cos # * time_factor
# Orientation reward
reward += self.hor_dist
# reward += 1 - np.tanh(2.0*d)
# reward += 1 - np.tanh(np.abs(t))
reward += cos
# if we're not reward shaping, we need to scale our sparse reward so that the max reward is identical
# to its dense version
else:
reward *= 5.0
if self.reward_scale is not None:
reward *= self.reward_scale
if (self.num_via_point == 1
and ((abs(self.hole_pos[0] - self.peg_pos[0]) > 0.014
or abs(self.hole_pos[1] - self.peg_pos[1]) > 0.014)
and self.peg_pos[2] < self.table_offset[2] + 0.1)
or self.horizon - self.timestep == 1
):
reward = 0 * -self.horizon / 3
# self.checked = (self.num_via_points-2)
# self.switch = 0
# self.switch_seq = 0
# self.success = 0
# # self.trans *= 3
# self.reset_via_point()
# self.built_min_jerk_traj()
return reward
def on_peg(self):
res = False
if (
abs(self.hole_pos[0] - self.peg_pos[0]) < 0.015
and abs(self.hole_pos[1] - self.peg_pos[1]) < 0.007
and abs(self.hole_pos[1] - self.peg_pos[1]) + abs(self.hole_pos[0] - self.peg_pos[0]) < 0.04
and self.peg_pos[2] < self.table_offset[2] + 0.05
):
res = True
return res
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose accordingly
xpos = self.robots[0].robot_model.base_xpos_offset["table"](self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
# load model for table top workspace
mujoco_arena = TableArena(
table_full_size=self.table_full_size,
table_friction=self.table_friction,
table_offset=self.table_offset,
)
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
self.peg_radius = 0.025
self.peg_height = 0.12
self.peg_z_offset = 0.9
self.rotation = None
x_range = [-0.0, 0.0]
y_range = [-0.1, -0.1]
# initialize objects of interest
self.peg = CylinderObject(name='peg',
size=[self.peg_radius, self.peg_height],
density=1,
duplicate_collision_geoms=True,
rgba=[1, 0, 0, 1], joints=None)
# load peg object (returns extracted object in XML form)
peg_obj = self.peg.get_obj()
# set pegs position relative to place where it is being placed
peg_obj.set("pos", array_to_string((0, 0, -0.04)))
peg_obj.append(new_site(name="peg_site", pos=(0, 0, self.peg_height), size=(0.005,)))
# append the object top the gripper (attach body to body)
# main_eef = self.robots[0].robot_model.eef_name # 'robot0_right_hand'
main_eef = self.robots[0].gripper.bodies[1] # 'gripper0_eef' body
main_model = self.robots[0].robot_model # <robosuite.models.robots.manipulators.ur5e_robot.UR5e at 0x7fd9ead87ca0>
main_body = find_elements(root=main_model.worldbody, tags="body", attribs={"name": main_eef}, return_first=True)
main_body.append(peg_obj) # attach body to body
if self.rotation is None:
rot_angle = np.random.uniform(high=2 * np.pi, low=0)
elif isinstance(self.rotation, collections.Iterable):
rot_angle = np.random.uniform(
high=max(self.rotation), low=min(self.rotation)
)
else:
rot_angle = self.rotation
hole_rot_set = str(np.array([np.cos(rot_angle / 2), 0, 0, np.sin(rot_angle / 2)]))
hole_pos_set = np.array([np.random.uniform(high=x_range[0], low=x_range[1]), np.random.uniform(high=y_range[0], low=y_range[1]), 0.83])
hole_pos_str = ' '.join(map(str, hole_pos_set))
hole_rot_str = ' '.join(map(str, hole_rot_set))
self.hole = PlateWithHoleObject(name='hole')
hole_obj = self.hole.get_obj()
hole_obj.set("quat", hole_rot_str)
hole_obj.set("pos", hole_pos_str)
self.model = ManipulationTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=self.hole
)
# Make sure to add relevant assets from peg and hole objects
self.model.merge_assets(self.peg)
## Create placement initializer
# if self.placement_initializer is not None:
# self.placement_initializer.reset()
# self.placement_initializer.add_objects(self.peg)
# else:
# """Object samplers use the bottom_site and top_site sites of each object in order to place objects on top of other objects,
# and the horizontal_radius_site site in order to ensure that objects do not collide with one another. """
# task includes arena, robot, and objects of interest
# self.model = ManipulationTask(
# mujoco_arena=mujoco_arena,
# mujoco_robots=[robot.robot_model for robot in self.robots],
# mujoco_objects=[self.peg],
# )
# def _load_model(self):
# """
# Loads an xml model, puts it in self.model
# """
# super()._load_model()
#
# # Adjust base pose accordingly
# xpos = self.robots[0].robot_model.base_xpos_offset["table"](self.table_full_size[0])
# self.robots[0].robot_model.set_base_xpos(xpos)
#
# # load model for table top workspace
# mujoco_arena = TableArena(
# table_full_size=self.table_full_size,
# table_friction=self.table_friction,
# table_offset=self.table_offset,
# )
#
# # Arena always gets set to zero origin
# mujoco_arena.set_origin([0, 0, 0])
#
# # initialize objects of interest
# tex_attrib = {
# "type": "cube",
# }
# mat_attrib = {
# "texrepeat": "1 1",
# "specular": "0.4",
# "shininess": "0.1",
# }
# redwood = CustomMaterial(
# texture="WoodRed",
# tex_name="redwood",
# mat_name="redwood_mat",
# tex_attrib=tex_attrib,
# mat_attrib=mat_attrib,
# )
# # self.cube = BoxObject(
# # name="cube",
# # size_min=[0.020, 0.020, 0.020], # [0.015, 0.015, 0.015],
# # size_max=[0.022, 0.022, 0.022], # [0.018, 0.018, 0.018])
# # rgba=[1, 0, 0, 1],
# # material=redwood,
# # )
# self.cube = PlateWithHoleObject(name="cube")
# # Create placement initializer
# if self.placement_initializer is not None:
# self.placement_initializer.reset()
# self.placement_initializer.add_objects(self.cube)
# else:
# self.placement_initializer = UniformRandomSampler(
# name="cube",
# mujoco_objects=self.cube,
# x_range=[-0.03, 0.03],
# y_range=[-0.03, 0.03],
# rotation=None,
# ensure_object_boundary_in_range=True,
# ensure_valid_placement=True,
# reference_pos=self.table_offset,
# z_offset=0.01,
# )
#
# self.placement_initializer.reset()
#
#
# # Add this nut to the placement initializerr
# self.placement_initializer.add_objects(self.cube)
# # task includes arena, robot, and objects of interest
# # self.hole = PlateWithHoleObject(name='hole',)
# # self.hole = PlateWith5mmHoleObject(name='peg_hole')
# # hole_obj = self.hole.get_obj()
# # hole_obj.set("quat", "0 0 0.707 0.707")
# # hole_obj.set("pos", "0.1 0.2 1.17")
#
# self.model = ManipulationTask(
# mujoco_arena=mujoco_arena,
# mujoco_robots=[robot.robot_model for robot in self.robots],
# mujoco_objects=self.cube,
# )
def _setup_references(self):
"""
Sets up references to important components. A reference is typically an
index or a list of indices that point to the corresponding elements
in a flatten array, which is how MuJoCo stores physical simulation data.
"""
super()._setup_references()
# Additional object references from this env
self.peg_body_id = self.sim.model.body_name2id(self.peg.root_body)
def _setup_observables(self):
"""
Sets up observables to be used for this environment. Creates object-based observables if enabled
Returns:
OrderedDict: Dictionary mapping observable names to its corresponding Observable object
"""
observables = super()._setup_observables()
# low-level object information
if self.use_object_obs:
# Get robot prefix and define observables modality
pf = self.robots[0].robot_model.naming_prefix
modality = "object"
# peg-related observables
@sensor(modality=modality)
def peg_pos(obs_cache):
return np.array(self.sim.data.body_xpos[self.peg_body_id])
@sensor(modality=modality)
def peg_quat(obs_cache):
return T.convert_quat(np.array(self.sim.data.body_xquat[self.peg_body_id]), to="xyzw")
@sensor(modality=modality)
def gripper_to_peg_pos(obs_cache):
return obs_cache[f"{pf}eef_pos"] - obs_cache["peg_pos"] if \
f"{pf}eef_pos" in obs_cache and "peg_pos" in obs_cache else np.zeros(3)
sensors = [peg_pos, peg_quat, gripper_to_peg_pos]
names = [s.__name__ for s in sensors]
# Create observables
for name, s in zip(names, sensors):
observables[name] = Observable(
name=name,
sensor=s,
sampling_rate=self.control_freq,
)
return observables
def _reset_internal(self):
"""
Resets simulation internal configurations.
"""
super()._reset_internal()
self.num_via_point = 0
self.success = 0
self.enter = 1
self.t_bias = 0
self.reset_via_point()
# Reset all object positions using initializer sampler if we're not directly loading from an xml
# if not self.deterministic_reset:
# Sample from the placement initializer for all objects
# object_placements = self.placement_initializer.sample()
#
# # Loop through all objects and reset their positions
# for obj_pos, obj_quat, obj in object_placements.values():
# self.sim.data.set_joint_qpos(obj.joints, np.concatenate([np.array(obj_pos), np.array(obj_quat)]))
def visualize(self, vis_settings):
"""
In addition to super call, visualize gripper site proportional to the distance to the peg.
Args:
vis_settings (dict): Visualization keywords mapped to T/F, determining whether that specific
component should be visualized. Should have "grippers" keyword as well as any other relevant
options specified.
"""
# Run superclass method first
super().visualize(vis_settings=vis_settings)
# Color the gripper visualization site according to its distance to the peg
if vis_settings["grippers"]:
self._visualize_gripper_to_target(gripper=self.robots[0].gripper, target=self.peg)
def _check_success(self):
"""
Check if peg is successfully aligned and placed within the hole
Returns:
bool: True if peg is placed in hole correctly
"""
# TODO - _check_success(self) - change this function
# calculat pegs end position.
self.r_reach = 0
self.hor_dist = 0
peg_mat = self.sim.data.body_xmat[self.peg_body_id]
peg_mat.shape = (3, 3)
peg_pos_center = self.sim.data.body_xpos[self.peg_body_id]
handquat = T.convert_quat(self.sim.data.get_body_xquat("robot0_right_hand"), to="xyzw")
handDCM = T.quat2mat(handquat)
self.peg_pos = self.sim.data.get_site_xpos(
"peg_site") # peg_pos_center + (handDCM @ [0, 0, 2*self.peg_length]).T
self.hole_pos = self.sim.data.get_site_xpos("hole_middle_cylinder")
hole_mat = self.sim.data.body_xmat[self.sim.model.body_name2id("hole_hole")]
hole_mat.shape = (3, 3)
dist = | np.linalg.norm(self.peg_pos - self.hole_pos) | numpy.linalg.norm |
import tclab
import time
import numpy as np
import sys
import first_principles_model as fp
def doublet_test(data_file='step_test.csv', show_plot=True):
'''doublet test the system and save data to given file path'''
import Adafruit_DHT # Only importable on the Pi itself
tc1 = tclab.TCLab()
tc1.LED(100)
# Bogus data row added to make concatenation work, never goes anywhere
data = [1, 1, 1, 1, 1, 1, 1, 1]
csv_file_header = 'time,control output,box humidity,box temp,outside humidity,outside temp,heater 1 temp,heater 2 temp,P,I,D,SP,Err'
start_time = time.time()
u = 0
tc1.Q1(u)
tc1.Q2(u)
current_time = 0
while current_time < 1200:
try:
# read temp, humidity and time
humid_in, temp_in = Adafruit_DHT.read_retry(
11, 4, retries=5, delay_seconds=1)
humid_out, temp_out = Adafruit_DHT.read_retry(
11, 17, retries=5, delay_seconds=1)
current_time = time.time() - start_time
if humid_in is None:
# Rejects failed readings
continue
if humid_in > 100:
# Corrupted data, so ignore it
continue
if current_time > 60:
u = 100
if current_time > 800:
u = 50
tc1.Q1(u)
tc1.Q2(u)
# print current values
print('time: {:.1f}, u: {}, h_in: {}, t_in: {}, h1: {}, h2: {}, h_out: {}, t_out: {}'
.format(current_time, u, humid_in, temp_in, tc1.T1, tc1.T2, humid_out, temp_out))
data = np.vstack([data, [current_time, u, humid_in,
temp_in, humid_out, temp_out, tc1.T1, tc1.T2]])
np.savetxt(data_file, data[1:],
delimiter=',', header=csv_file_header)
except KeyboardInterrupt:
print('Exiting...')
tc1.LED(0)
return
except ValueError as error:
# Handles cases when the heater overheats
print(error)
def run_controller(run_time, PID_parameters, show_plot=True):
'''
Run the main loop
run_time total run time in minutes
show_plot whether to show the dynamic plot of the system
'''
Kc, tau_I, tau_D = PID_parameters
import Adafruit_DHT # Only importable on the Pi itself
tc1 = tclab.TCLab()
tc1.LED(100)
# Bogus data row added to make concatenation work, never goes anywhere
data = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
csv_file_header = 'time,control output,box humidity,box temp,outside humidity,outside temp,heater 1 temp,heater 2 temp,P,I,D,SP,Err'
start_time = time.time()
u = 0
Qss = 0 # 0% heater to start
err = | np.zeros(run_time*60) | numpy.zeros |
from torchvision.transforms import ToTensor, Compose, RandomAffine
from torch.utils.data import Dataset
import pandas as pd
from os.path import join
from PIL import Image, ImageOps
import numpy as np
import random
class SketchyDB(Dataset):
""" class representing the Sketchy Database """
def __init__(self, root_dir, sketch_type='sketch', sketch_difficulties=(1, 2, 3, 4),
filter_erroneous=False, filter_context=False, filter_ambiguous=False, filter_pose=False,
train=True, split=0.8, sketch_augmentation=False, seed=1337):
"""
:param root_dir: root directory of the dataset
:param sketch_type: which sketch augmentation to use ('sketch', 'centered_scaled',
'centered_bbox', 'centered_bbox_scaled_least', 'centered_bbox_scaled_most'
or 'centered_bbox_scaled_nonuniform'):
'sketch' : sketch canvas is rendered to 256x256 such that it
undergoes the same scaling as the paired photo
'centered_scaled' : sketch is centered and uniformly scaled
such that its greatest dimension (x or y)
fills 78% of the canvas (roughly the same
as in Eitz 2012 sketch data set)
'centered_bbox' : sketch is translated such that it is
centered on the object bounding box
'centered_bbox_scaled_least' : sketch is centered on bounding box and
is uniformly scaled such that one dimension
(x or y; whichever requires the least amount
of scaling) fits within the bounding box
'centered_bbox_scaled_most' : sketch is centered on bounding box and
is uniformly scaled such that one dimension
(x or y; whichever requires the most amount
of scaling) fits within the bounding box
'centered_bbox_scaled_nonuniform' : sketch is centered on bounding box and
is non-uniformly scaled such that it
completely fits within the bounding box
:param sketch_difficulties: between 1 and 4, list of difficulties to use
:param filter_erroneous: filter sketches tagged as erroneous
:param filter_context: filter sketches tagged as containing context
:param filter_ambiguous: filter sketches tagged as ambiguous
:param filter_pose: filter sketches tagged with an incorrect pose
:param train: train or test set
:param split: train/test ratio
:param sketch_augmentation: whether to augment sketches
"""
sketch_folders = {'sketch': 'tx_000000000000',
'centered_scaled': 'tx_000100000000',
'centered_bbox': 'tx_000000000010',
'centered_bbox_scaled_least': 'tx_000000000110',
'centered_bbox_scaled_most': 'tx_000000001010',
'centered_bbox_scaled_nonuniform': 'tx_000000001110'}
self.sketch_dir = join(root_dir, 'sketch', sketch_folders[sketch_type])
self.sketch_augmentation = sketch_augmentation
if sketch_augmentation is True:
self.sketch_augmentation_transform = Compose([RandomAffine(10,
translate=(0.08, 0.08),
scale=(0.9, 1.1),
fillcolor=255,
shear=10)])
self.sketch_transform = Compose([ToTensor()])
database_dir = join(root_dir, 'info/stats.csv')
df = pd.read_csv(database_dir, usecols=['CategoryID', 'Category', 'ImageNetID', 'SketchID', 'Difficulty',
'Error?', 'Context?', 'Ambiguous?', 'WrongPose?'])
# filter data
df = df[df['Difficulty'].isin(sketch_difficulties)]
if filter_erroneous is True:
df = df[df['Error?'] == 0]
if filter_context is True:
df = df[df['Context?'] == 0]
if filter_ambiguous is True:
df = df[df['Ambiguous?'] == 0]
if filter_pose is True:
df = df[df['WrongPose?'] == 0]
self.seed = seed
self.train = train
self.data = df
self.num_samples = len(self.data.index)
self.indices = list(range(self.num_samples))
random.Random(self.seed).shuffle(self.indices)
if self.train is True:
self.indices = self.indices[:int(len(self.indices) * split)]
else:
self.indices = self.indices[int(len(self.indices) * split):]
self.num_samples = len(self.indices)
self.num_classes = df['CategoryID'].nunique()
def __len__(self):
return self.num_samples * 2 if self.train is True else self.num_samples # (*2 for flipping every single sample)
def __getitem__(self, idx):
hflip = False
if self.train:
idx = idx // 2
hflip = (idx % 2 == 0)
idx = self.indices[idx]
sketch_path = join(self.sketch_dir, self.data.iloc[idx]['Category'].replace(' ', '_'),
f'{self.data.iloc[idx]["ImageNetID"]}-{self.data.iloc[idx]["SketchID"]}.png')
sketch = Image.open(sketch_path).resize((224, 224))
if self.sketch_augmentation is True:
sketch = self.sketch_augmentation_transform(sketch)
if hflip is True:
sketch = sketch.transpose(Image.FLIP_LEFT_RIGHT)
sketch = ImageOps.invert(sketch)
sketch = | np.array(sketch) | numpy.array |
#%%
"""
Created on July 05 2021
Simulation of, E(W(t)|F(s)) = W(s) using nested Monte Carlo
This code is purely educational and comes from "Financial Engineering" course by <NAME>
The course is based on the book “Mathematical Modeling and Computation
in Finance: With Exercises and Python and MATLAB Computer Codes”,
by <NAME> and <NAME>, World Scientific Publishing Europe Ltd, 2019.
@author: <NAME>
"""
import numpy as np
import matplotlib.pyplot as plt
t = 10
s = 5
NoOfPaths=1000
NoOfSteps=10
# First part to caclulate E(W(t)|F(0)) = W(0)=0
def martingaleA():
W_t = np.random.normal(0.0,pow(t,0.5),[NoOfPaths,1])
E_W_t = np.mean(W_t)
print("mean value equals to: %.2f while the expected value is W(0) =%0.2f " %(E_W_t,0.0))
# Second part requiring nested Monte Carlo simulation E(W(t)|F(s)) = W(s)
def martingaleB():
Z = np.random.normal(0.0,1.0,[NoOfPaths,NoOfSteps])
W = np.zeros([NoOfPaths,NoOfSteps+1])
# time-step from [t0,s]
dt1 = s / float(NoOfSteps)
for i in range(0,NoOfSteps):
# making sure that samples from normal have mean 0 and variance 1
Z[:,i] = (Z[:,i] - np.mean(Z[:,i])) / np.std(Z[:,i])
W[:,i+1] = W[:,i] + pow(dt1,0.5)*Z[:,i]
#W_s is the last column of W
W_s = W[:,-1]
#for every path W(s) we perform sub-simulation until time t and calculate
#the expectation
# time-step from [s,t]
dt2 = (t-s)/float(NoOfSteps);
W_t = np.zeros([NoOfPaths,NoOfSteps+1]);
#Store the results
E_W_t = np.zeros([NoOfPaths])
Error=[]
for i in range(0,NoOfPaths):
#Sub-simulation from time "s" until "t"
W_t[:,0] = W_s[i];
Z = | np.random.normal(0.0,1.0,[NoOfPaths,NoOfSteps]) | numpy.random.normal |
# coding: utf-8
#
# This code is part of lattpy.
#
# Copyright (c) 2021, <NAME>
#
# This code is licensed under the MIT License. The copyright notice in the
# LICENSE file in the root directory and this permission notice shall
# be included in all copies or substantial portions of the Software.
"""This module contains the main `Lattice` object."""
import pickle
import logging
import warnings
import itertools
import collections
import numpy as np
from copy import deepcopy
from scipy.spatial.distance import cdist
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d.axes3d import Axes3D
from typing import Union, Optional, Tuple, List, Iterator, Sequence, Callable, Any, Dict
from .utils import (
ArrayLike,
frmt_num,
SiteOccupiedError,
NoAtomsError,
NoBaseNeighborsError,
NotBuiltError
)
from .spatial import (
build_periodic_translation_vector,
vindices,
interweave,
cell_size,
cell_volume,
WignerSeitzCell,
KDTree
)
from .plotting import (
draw_points,
draw_vectors,
draw_cell,
draw_indices
)
from .unitcell import Atom
from .data import LatticeData
__all__ = ["Lattice"]
logger = logging.getLogger(__name__)
class Lattice:
"""Object representing the basis and data of a bravais lattice."""
DIST_DECIMALS: int = 6 # Decimals used for rounding distances
RVEC_TOLERANCE: float = 1e-6 # Tolerance for reciprocal vectors/lattice
def __init__(self, vectors: Union[float, Sequence[float], Sequence[Sequence[float]]],
**kwargs):
"""Initialize a new ``Lattice`` instance.
Parameters
----------
vectors: array_like or float
The vectors that span the basis of the lattice.
"""
# Vector basis
self._vectors = np.atleast_2d(vectors).T
self._vectors_inv = np.linalg.inv(self._vectors)
self._dim = len(self._vectors)
self._cell_size = cell_size(self.vectors)
self._cell_volume = cell_volume(self.vectors)
# Atom data
self._num_base = 0
self._atoms = list()
self._positions = list()
# Raw neighbor data without including connections
self._raw_base_neighbors = None
self._raw_distance_matrix = None
self._raw_num_neighbors = None
# Neighbour data
self._connections = None
self._base_neighbors = None
self._num_neighbors = None
self._distance_matrix = None
self._distances = None
# Lattice Cache
self.data = LatticeData()
self.shape = None
self.periodic_axes = list()
logger.debug("Lattice initialized (D=%i)\n"
"vectors:\n%s", self.dim, self._vectors)
@classmethod
def chain(cls, a: Optional[float] = 1.0, **kwargs) -> 'Lattice':
return cls(a, **kwargs)
@classmethod
def square(cls, a: Optional[float] = 1.0, **kwargs) -> 'Lattice':
return cls(a * np.eye(2), **kwargs)
@classmethod
def rectangular(cls, a1: Optional[float] = 1., a2: Optional[float] = 1., **kwargs) -> 'Lattice':
return cls(np.array([[a1, 0], [0, a2]]), **kwargs)
@classmethod
def hexagonal(cls, a: Optional[float] = 1.0, **kwargs) -> 'Lattice':
vectors = a / 2 * np.array([[3, np.sqrt(3)], [3, -np.sqrt(3)]])
return cls(vectors, **kwargs)
@classmethod
def oblique(cls, alpha: float, a1: Optional[float] = 1.0,
a2: Optional[float] = 1.0, **kwargs) -> 'Lattice':
vectors = np.array([[a1, 0], [a2 * np.cos(alpha), a2 * np.sin(alpha)]])
return cls(vectors, **kwargs)
@classmethod
def hexagonal3D(cls, a: Optional[float] = 1., az: Optional[float] = 1., **kwargs) -> 'Lattice': # noqa
vectors = a / 2 * np.array([[3, np.sqrt(3), 0], [3, -np.sqrt(3), 0], [0, 0, az]])
return cls(vectors, **kwargs)
@classmethod
def sc(cls, a: Optional[float] = 1.0, **kwargs) -> 'Lattice':
return cls(a * np.eye(3), **kwargs)
@classmethod
def fcc(cls, a: Optional[float] = 1.0, **kwargs) -> 'Lattice':
vectors = a/2 * np.array([[1, 1, 0], [1, 0, 1], [0, 1, 1]])
return cls(vectors, **kwargs)
@classmethod
def bcc(cls, a: Optional[float] = 1.0, **kwargs) -> 'Lattice':
vectors = a/2 * np.array([[1, 1, 1], [1, -1, 1], [-1, 1, 1]])
return cls(vectors, **kwargs)
# ==============================================================================================
@property
def dim(self) -> int:
"""int : The dimension of the vector basis."""
return self._dim
@property
def vectors(self) -> np.ndarray:
"""np.ndarray : Array with basis vectors as rows."""
return self._vectors.T
@property
def vectors3d(self) -> np.ndarray:
"""np.ndarray : Basis vectors expanded to three dimensions."""
vectors = np.eye(3)
vectors[:self.dim, :self.dim] = self._vectors
return vectors.T
@property
def norms(self) -> np.ndarray:
"""np.ndarray : Lengths of the basis-vectors."""
return np.linalg.norm(self._vectors, axis=0)
@property
def cell_size(self) -> np.ndarray:
"""np.ndarray : The shape of the box spawned by the given vectors."""
return self._cell_size
@property
def cell_volume(self) -> float:
"""float : The volume of the unit cell defined by the primitive vectors."""
return self._cell_volume
@property
def num_base(self) -> int:
"""int : The number of atoms in the unitcell."""
return self._num_base
@property
def atoms(self) -> List[Atom]:
"""list of Atom : List of the atoms in the unitcell."""
return self._atoms
@property
def atom_positions(self) -> List[np.ndarray]:
"""list of np.ndarray : List of corresponding positions of the atoms in the unitcell."""
return self._positions
@property
def num_distances(self) -> int:
"""int : The maximal number of distances between the lattice sites."""
return int(np.max(self._connections))
@property
def num_neighbors(self) -> np.ndarray:
"""np.ndarray : The number of neighbors of each atom in the unitcell."""
return self._num_neighbors
@property
def base_neighbors(self):
"""The neighbors of the unitcell at the origin."""
return self._base_neighbors
@property
def distances(self) -> np.ndarray:
"""List of distances between the lattice sites."""
return self._distances
@property
def num_sites(self) -> int:
"""int : Number of sites in lattice data (only available if lattice has been built)."""
return self.data.num_sites
@property
def num_cells(self) -> int:
"""int : Number of unit-cells in lattice data (only available if lattice has been built)."""
return np.unique(self.data.indices[:, :-1], axis=0).shape[0]
def itransform(self, world_coords: Union[Sequence[int], Sequence[Sequence[int]]]) -> np.ndarray:
"""Transform the world-coordinates (x, y, ...) into the basis coordinates (n, m, ...)
Parameters
----------
world_coords : (..., N) array_like
Returns
-------
basis_coords : (..., N) np.ndarray
"""
world_coords = np.atleast_1d(world_coords)
return np.inner(world_coords, self._vectors_inv)
def transform(self, basis_coords: Union[Sequence[int], Sequence[Sequence[int]]]) -> np.ndarray:
""" Transform the basis-coordinates (n, m, ...) into the world coordinates (x, y, ...)
Parameters
----------
basis_coords : (..., N) array_like
Returns
-------
world_coords : (..., N) np.ndarray
"""
basis_coords = np.atleast_1d(basis_coords)
return np.inner(basis_coords, self._vectors)
def translate(self, nvec: Union[int, Sequence[int], Sequence[Sequence[int]]],
r: Optional[Union[float, Sequence[float]]] = 0.0) -> np.ndarray:
r""" Translates the given postion vector r by the translation vector n.
The position is calculated using the translation vector .math`n` and the
atom position in the unitcell .math:`r`:
..math::
R = \sum_i n_i v_i + r
Parameters
----------
nvec : (..., N) array_like
Translation vector in the lattice basis.
r : (N) array_like, optional
The position in cartesian coordinates. If no vector is passed only
the translation is returned.
Returns
-------
r_trans : (N) np.ndarray
"""
r = np.atleast_1d(r)
nvec = np.atleast_1d(nvec)
return r + | np.inner(nvec, self._vectors) | numpy.inner |
import unittest
import raocp.core.cones as core_cones
import numpy as np
class TestCones(unittest.TestCase):
__real = core_cones.Real()
__zero = core_cones.Zero()
__nonnegative_orthant = core_cones.NonnegativeOrthant()
__second_order_cone = core_cones.SecondOrderCone()
__cartesian = core_cones.Cartesian([__real, __zero, __nonnegative_orthant, __second_order_cone])
__num_samples = 100
__sample_multiplier = 10
__cone_dimension = 20
__num_test_repeats = 100
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
def test_dimension_check(self):
# cone size equals vector size
_ = core_cones._check_dimension("Real", 5, np.ones(5))
def test_dimension_check_failure(self):
# cone size does not equal vector size
with self.assertRaises(ValueError):
_ = core_cones._check_dimension("Real", 5, np.ones(6))
def test_real_project(self):
# create cone
cone_type = "Real"
real = TestCones.__real
# create point for projection
vector = np.array(TestCones.__sample_multiplier * np.random.rand(TestCones.__cone_dimension))\
.reshape((TestCones.__cone_dimension, 1))
# create points for test
samples = [None] * TestCones.__num_samples
for i in range(TestCones.__num_samples):
samples[i] = np.random.randint(-100, 100, 20) # real samples
# test real cone
self.assertEqual(cone_type, type(real).__name__)
projection = real.project(vector)
for i in range(TestCones.__num_samples):
self.assertTrue(np.inner(vector.reshape((TestCones.__cone_dimension,))
- projection.reshape((TestCones.__cone_dimension,)),
samples[i].reshape((TestCones.__cone_dimension,))
- projection.reshape((TestCones.__cone_dimension,))) <= 0)
def test_real_project_dual(self):
# create cone
cone_type = "Real"
real = TestCones.__real
# create point for projection
vector = np.array(TestCones.__sample_multiplier * np.random.rand(TestCones.__cone_dimension)) \
.reshape((TestCones.__cone_dimension, 1))
# create points for test
dual_samples = [None] * TestCones.__num_samples
for i in range(TestCones.__num_samples):
dual_samples[i] = np.zeros(TestCones.__cone_dimension) # real dual samples (zero)
# test real cone
self.assertEqual(cone_type, type(real).__name__)
projection_onto_dual = real.project_onto_dual(vector)
for i in range(TestCones.__num_samples):
self.assertTrue(np.inner(vector.reshape((TestCones.__cone_dimension,))
- projection_onto_dual.reshape((TestCones.__cone_dimension,)),
dual_samples[i].reshape((TestCones.__cone_dimension,))
- projection_onto_dual.reshape((TestCones.__cone_dimension,))) <= 0)
def test_zero_project(self):
# create cone
cone_type = "Zero"
zero = TestCones.__zero
# create points for projection
vector = np.array(TestCones.__sample_multiplier * np.random.rand(TestCones.__cone_dimension))\
.reshape((TestCones.__cone_dimension, 1))
samples = [None] * TestCones.__num_samples
for i in range(TestCones.__num_samples):
samples[i] = np.zeros(TestCones.__cone_dimension) # zero samples
# test zero
self.assertEqual(cone_type, type(zero).__name__)
projection = zero.project(vector)
for i in range(TestCones.__num_samples):
self.assertTrue(np.inner(vector.reshape((TestCones.__cone_dimension,))
- projection.reshape((TestCones.__cone_dimension,)),
samples[i].reshape((TestCones.__cone_dimension,))
- projection.reshape((TestCones.__cone_dimension,))) <= 0)
def test_zero_project_dual(self):
# create cone
cone_type = "Zero"
zero = TestCones.__zero
# create points for projection
vector = np.array(TestCones.__sample_multiplier * np.random.rand(TestCones.__cone_dimension))\
.reshape((TestCones.__cone_dimension, 1))
dual_samples = [None] * TestCones.__num_samples
for i in range(TestCones.__num_samples):
dual_samples[i] = np.random.randint(-100, 100, TestCones.__cone_dimension) # zero dual samples (real)
# test zero dual
self.assertEqual(cone_type, type(zero).__name__)
projection_onto_dual = zero.project_onto_dual(vector)
for i in range(TestCones.__num_samples):
self.assertTrue(np.inner(vector.reshape((TestCones.__cone_dimension,))
- projection_onto_dual.reshape((TestCones.__cone_dimension,)),
dual_samples[i].reshape((TestCones.__cone_dimension,))
- projection_onto_dual.reshape((TestCones.__cone_dimension,))) <= 0)
def test_nonnegative_orthant_project(self):
# create cone
cone_type = "NonnegativeOrthant"
nonnegative_orthant = TestCones.__nonnegative_orthant
# create points for projection
vector = np.array(TestCones.__sample_multiplier * np.random.rand(TestCones.__cone_dimension))\
.reshape((TestCones.__cone_dimension, 1))
samples = [None] * TestCones.__num_samples
for i in range(TestCones.__num_samples):
samples[i] = np.random.randint(0, 100, TestCones.__cone_dimension) # non samples
# test non
self.assertEqual(cone_type, type(nonnegative_orthant).__name__)
projection = nonnegative_orthant.project(vector)
for i in range(TestCones.__num_samples):
self.assertTrue(np.inner(vector.reshape((TestCones.__cone_dimension,))
- projection.reshape((TestCones.__cone_dimension,)),
samples[i].reshape((TestCones.__cone_dimension,))
- projection.reshape((TestCones.__cone_dimension,))) <= 0)
def test_nonnegative_orthant_project_dual(self):
# create cone
cone_type = "NonnegativeOrthant"
nonnegative_orthant = TestCones.__nonnegative_orthant
# create points for projection
vector = np.array(TestCones.__sample_multiplier * | np.random.rand(TestCones.__cone_dimension) | numpy.random.rand |
import numpy as np
import pandas as pd
import ml_metrics
import base64
import matplotlib.pyplot as plt
import seaborn as sns
from mlxtend.frequent_patterns import apriori
from scipy.sparse import csc_matrix
from scipy.sparse.linalg import svds
from IPython.display import HTML
"""
redcarpet: Module for recommender systems using sets
"""
"""
HELPER METHODS
"""
def nonzero_index_set(arr):
"""
Returns a set of indices corresponding to non-zero
entries in a numpy array (or other list-like).
"""
res = set()
for i, val in enumerate(arr):
if val > 0:
res.add(i)
return res
def mat_to_sets(mat):
"""
Converts a numpy matrix into a list of sets of column
indices corresponding to non-zero row entries.
"""
return [nonzero_index_set(row) for row in mat]
def get_recs(user_recs, k=None):
"""
Extracts recommended item indices, leaving out their scores.
params:
user_recs: list of lists of tuples of recommendations where
each tuple has (item index, relevance score) with the
list of tuples sorted in order of decreasing relevance
k: maximumum number of recommendations to include for each
user, if None, include all recommendations
returns:
list of lists of recommendations where each
list has the column indices of recommended items
sorted in order they appeared in user_recs
"""
recs = [[item for item, score in recs][0:k] for recs in user_recs]
return recs
def write_kaggle_recs(recs_list, filename=None, headers=["Id", "Predicted"]):
"""
Writes recommendations to file in Kaggle submission format.
params:
recs_list: list of lists of recommendations where each
list has the column indices of recommended items
sorted in order of decreasing relevance
filename: path to file for writing output
headers: list of strings of output columns, defaults to
submission columns: ["Id", "Predicted"]
returns:
int: number of non-header lines, where each line represents
a user and the recommendations given to them
"""
if filename is None:
raise ValueError("Must provide a filename.")
lines = [",".join(headers)]
for i, recs in enumerate(recs_list):
lines.append("{},{}".format(i, " ".join([str(v) for v in recs])))
text = "\n".join(lines)
with open(filename, "w") as file:
file.write(text)
return len(lines) - 1
def download_kaggle_recs(recs_list, filename=None, headers=["Id", "Predicted"]):
"""
Writes recommendations to file in Kaggle submission format.
params:
recs_list: list of lists of recommendations where each
list has the column indices of recommended items
sorted in order of decreasing relevance
filename: path to file for writing output
headers: list of strings of output columns, defaults to
submission columns: ["Id", "Predicted"]
returns:
html: HTML download link to display in a notebook, click
to download the submission file
"""
# Based on: https://www.kaggle.com/rtatman/download-a-csv-file-from-a-kernel
if filename is None:
raise ValueError("Must provide a filename.")
rec_df = pd.DataFrame(
[(i, " ".join([str(r) for r in recs])) for i, recs in enumerate(recs_list)],
columns=headers,
)
csv = rec_df.to_csv(index=False)
b64 = base64.b64encode(csv.encode())
payload = b64.decode()
html = """<a download="{filename}"
href="data:text/csv;base64,{payload}"
target="_blank">Download ({lines} lines): {filename}</a>"""
html = html.format(payload=payload, filename=filename, lines=len(rec_df))
return HTML(html)
def check_list_of_sets(s_data, var_name):
if not isinstance(s_data, list):
raise ValueError(
"{} must be a list of sets. Got: {}".format(var_name, type(s_data))
)
if len(s_data) > 0:
entry = s_data[0]
if not isinstance(entry, set):
raise ValueError(
"{} must be a list of sets. Got list of: {}".format(
var_name, type(entry)
)
)
"""
EVALUATION METRICS
"""
def mapk_score(s_hidden, recs_pred, k=10):
"""
Computes the mean average precision at k (MAP@K) of recommendations.
MAP@K = mean AP@K score over all users
AP@K = (1 / min(m, k)) * sum from 1 to k of (precision at i * relevance of ith item)
Where m is the number of items in a user's hidden set
Where k is the number of items recommended to each user
params:
s_hidden: list of sets of hidden items for each user
recs_pred: list of lists of recommended items, with each list
k: number of recommendations to use in top set
returns:
float, range [0, 1]
"""
check_list_of_sets(s_hidden, "s_hidden")
return ml_metrics.mapk(s_hidden, recs_pred, k)
def uhr_score(s_hidden, recs_pred, k=10):
"""
Computes the user hit rate (UHR) score of recommendations.
UHR = the fraction of users whose top list included at
least one item also in their hidden set.
params:
s_hidden: list of sets of hidden items for each user
recs_pred: list of lists of recommended items, with each list
k: number of recommendations to use in top set
returns:
float, range [0, 1]
"""
check_list_of_sets(s_hidden, "s_hidden")
if len(s_hidden) != len(recs_pred):
note = "Length of true list {} does not match length of recommended list {}."
raise ValueError(note.format(len(s_hidden), len(recs_pred)))
scores = []
for r_true, r_pred_orig in zip(s_hidden, recs_pred):
r_pred = list(r_pred_orig)[0:k]
intersect = set(r_true).intersection(set(r_pred))
scores.append(1 if len(intersect) > 0 else 0)
return np.mean(scores)
def get_apk_scores(s_hidden, recs_pred, k=10):
"""
Returns the average precision at k (AP@K) for each user.
AP@K = (1 / min(m, k)) * sum from 1 to k of (precision at i * relevance of ith item)
Where m is the number of items in a user's hidden set
Where k is the number of items recommended to each user
params:
s_hidden: list of sets of hidden items for each user
recs_pred: list of lists of recommended items, with each list
k: number of recommendations to use in top set
returns:
list of floats, each float in the range [0, 1]
"""
check_list_of_sets(s_hidden, "s_hidden")
apks = []
for r_true, r_pred in zip(s_hidden, recs_pred):
apk = mapk_score([r_true], [r_pred], k=k)
apks.append(apk)
return apks
def get_hit_counts(s_hidden, recs_pred, k=10):
"""
Returns the number of successful recommendations for each user.
params:
s_hidden: list of sets of hidden items for each user
recs_pred: list of lists of recommended items, with each list
k: number of recommendations to use in top set
returns:
list of integers, each integer in the range [0, k]
"""
check_list_of_sets(s_hidden, "s_hidden")
hits = []
for r_true, r_pred in zip(s_hidden, recs_pred):
ix = r_true.intersection(set(r_pred[0:k]))
hits.append(len(ix))
return hits
def get_all_scores(rec_scores, k=10):
"""
Get scores of all items in the list of lists of recommendations.
"""
all_scores = []
for recs in rec_scores:
for (item, score) in recs[0:k]:
all_scores.append(score)
return all_scores
"""
ANALYSIS TOOLS
"""
def show_apk_dist(s_hidden, models, k=10, bin_size=0.1):
"""
Plot a histogram of average precision scores for all users.
"""
bins = np.arange(0, 1 + bin_size, bin_size)
pal = sns.color_palette("hls", len(models))
for ((rec_scores, name), color) in zip(models, pal):
apks = get_apk_scores(s_hidden, get_recs(rec_scores), k=k)
sns.distplot(apks, kde=False, label=name, bins=bins, color=color)
plt.xticks(bins)
plt.xlabel("Average Precision in Top {}".format(k))
plt.ylabel("Number of Users")
plt.title("AP@K Score Distribution")
plt.gcf().set_size_inches((8, 5))
plt.grid()
plt.legend(
loc="upper left", bbox_to_anchor=(1.0, 1.0), title="Models", frameon=False
)
plt.show()
def show_hit_dist(s_hidden, models, k=10):
"""
Plot a histogram of hit counts for all users.
"""
bins = range(k + 1)
pal = sns.color_palette("hls", len(models))
for ((rec_scores, name), color) in zip(models, pal):
hits = get_hit_counts(s_hidden, get_recs(rec_scores), k=k)
sns.distplot(hits, kde=False, label=name, bins=bins, color=color)
plt.xticks(bins)
plt.xlabel("Number of Successful Recommendations in Top {}".format(k))
plt.ylabel("Number of Users")
plt.title("Hit Count Distribution")
plt.gcf().set_size_inches((8, 5))
plt.grid()
plt.legend(
loc="upper left", bbox_to_anchor=(1.0, 1.0), title="Models", frameon=False
)
plt.show()
def show_score_dist(models, k=10, bins=None):
"""
Plot a histogram of item recommendation scores for all users.
"""
pal = sns.color_palette("hls", len(models))
for ((rec_scores, name), color) in zip(models, pal):
scores = get_all_scores(rec_scores, k=k)
if bins is not None:
sns.distplot(scores, kde=False, label=name, color=color, bins=bins)
else:
sns.distplot(scores, kde=False, label=name, color=color)
if bins is not None:
plt.xticks(bins)
plt.xlabel("Score for Recommended Item in Top {}".format(k))
plt.ylabel("Number of Items")
plt.title("Item Score Distribution")
plt.gcf().set_size_inches((8, 5))
plt.grid()
plt.legend(
loc="upper left", bbox_to_anchor=(1.0, 1.0), title="Models", frameon=False
)
plt.show()
def show_user_detail(s_input, s_hidden, rec_scores, uid, name_fn=None, k=10):
"""
Show the detailed results of recommendations to a user.
"""
s_pred = get_recs(rec_scores)
print("User: {}".format(uid))
print("Given: {}".format(sorted(s_input[uid])))
print("Recommended: {}".format(sorted(s_pred[uid])))
print("Actual: {}".format(sorted(s_hidden[uid])))
set_intersect = set(s_pred[uid]).intersection(set(s_hidden[uid]))
n_intersect = len(set_intersect)
apk = mapk_score([s_hidden[uid]], [s_pred[uid]], k)
print()
print("Recommendation Hits = {}".format(n_intersect))
print("Average Precision = {0:.3f}".format(apk))
print()
print("All Recommendation Scores:")
for i, (item_id, score) in enumerate(rec_scores[uid]):
hit = "Y" if item_id in s_hidden[uid] else " "
item_name = "Item {}".format(item_id)
if name_fn is not None:
item_name = name_fn(item_id)
print(
"{0}. [{3}] ({2:.3f}) {1}".format(
str(i + 1).zfill(2), item_name, score, hit
)
)
def show_user_recs(s_hidden, rec_scores, k=10):
"""
Show a table of recommendation results by user.
"""
apks = get_apk_scores(s_hidden, get_recs(rec_scores), k=k)
hits = get_hit_counts(s_hidden, get_recs(rec_scores), k=k)
cols = ["User", "APK", "Hits"]
data = {"User": range(len(rec_scores)), "APK": apks, "Hits": hits}
return pd.DataFrame(data)[cols]
def show_item_recs(s_hidden, rec_scores, k=10):
"""
Show a table of recommendation results by item.
"""
item_res = {}
for (user, likes) in zip(rec_scores, s_hidden):
for (i, score) in user:
if i not in item_res:
item_res[i] = {"Item": i, "Results": [], "Scores": []}
item_res[i]["Results"].append(1 if i in likes else 0)
item_res[i]["Scores"].append(score)
res = []
for i in item_res:
record = item_res[i]
total = len(record["Results"])
hits = sum(record["Results"])
res.append(
{
"Item": i,
"Recommended": total,
"Hits": hits,
"Hit Rate": hits / total,
"Avg Score": | np.mean(record["Scores"]) | numpy.mean |
import random
import numpy as np
import cv2
import torch
import torch.utils.data as data
import data.util as util
import os.path as osp
class LQGT_dataset(data.Dataset):
def __init__(self, opt):
super(LQGT_dataset, self).__init__()
self.opt = opt
self.data_type = self.opt['data_type']
self.paths_LQ, self.paths_GT = None, None
self.sizes_GT, self.paths_GT = util.get_image_paths(self.data_type, opt['dataroot_GT'])
self.sizes_LQ, self.paths_LQ = util.get_image_paths(self.data_type, opt['dataroot_LQ'])
assert self.paths_GT, 'Error: GT path is empty.'
if self.paths_LQ and self.paths_GT:
assert len(self.paths_LQ) == len(
self.paths_GT
), 'GT and LQ datasets have different number of images - {}, {}.'.format(
len(self.paths_LQ), len(self.paths_GT))
self.mask_folder = opt['dataroot_mask']
def __getitem__(self, index):
GT_path, LQ_path = None, None
scale = self.opt['scale']
GT_size = self.opt['GT_size']
# get GT image
GT_path = self.paths_GT[index]
img_GT = util.read_img(None, GT_path)
# get LQ image
LQ_path = self.paths_LQ[index]
img_LQ = util.read_img(None, LQ_path)
# get mask when mask folder is not None
if self.mask_folder is not None:
mask_name = osp.basename(LQ_path)[:-4] + '.npy'
mask_path = osp.join(self.mask_folder, mask_name)
mask = util.read_npy(mask_path)
mask = np.expand_dims(mask, 2).repeat(3, axis=2)
if self.opt['phase'] == 'train':
H, W, C = img_LQ.shape
H_gt, W_gt, C = img_GT.shape
if H != H_gt:
print('*******wrong image*******:{}'.format(LQ_path))
LQ_size = GT_size // scale
# randomly crop
if GT_size is not None:
rnd_h = random.randint(0, max(0, H - LQ_size))
rnd_w = random.randint(0, max(0, W - LQ_size))
img_LQ = img_LQ[rnd_h:rnd_h + LQ_size, rnd_w:rnd_w + LQ_size, :]
rnd_h_GT, rnd_w_GT = int(rnd_h * scale), int(rnd_w * scale)
img_GT = img_GT[rnd_h_GT:rnd_h_GT + GT_size, rnd_w_GT:rnd_w_GT + GT_size, :]
# augmentation - flip, rotate
img_LQ, img_GT = util.augment([img_LQ, img_GT], self.opt['use_flip'],
self.opt['use_rot'])
# resize for alignment
H, W, C = img_LQ.shape
if H%32!=0 or W%32!=0:
H_new = int(np.ceil(H / 32) * 32)
W_new = int(np.ceil(W / 32) * 32)
img_LQ = cv2.resize(img_LQ, (W_new, H_new))
img_GT = cv2.resize(img_GT, (W_new, H_new))
if self.mask_folder is None:
r = 0.95
mask = np.max(img_LQ, 2)
mask = np.minimum(1.0, np.maximum(0, mask - r) / (1 - r))
mask = | np.expand_dims(mask, 2) | numpy.expand_dims |
import logging
import numpy as np
from ctapipe.calib.camera import CameraCalibrator
from ctapipe.io import (
EventSource,
read_table,
)
from numba import njit
from scipy.interpolate import interp1d
from traitlets.config import Config
from lstchain.io import standard_config
from lstchain.io.config import read_configuration_file
__all__ = [
'add_noise_in_pixels',
'calculate_required_additional_nsb',
'calculate_noise_parameters',
'random_psf_smearer',
'set_numba_seed',
'tune_nsb_on_waveform',
]
log = logging.getLogger(__name__)
# number of neighbors of completely surrounded pixels of hexagonal cameras:
N_PIXEL_NEIGHBORS = 6
SMEAR_PROBABILITIES = np.full(N_PIXEL_NEIGHBORS, 1 / N_PIXEL_NEIGHBORS)
def add_noise_in_pixels(rng, image, extra_noise_in_dim_pixels,
extra_bias_in_dim_pixels, transition_charge,
extra_noise_in_bright_pixels):
"""
Addition of Poissonian noise to the pixels
Parameters
----------
rng : `numpy.random.default_rng`
Random number generator
image: `np.ndarray`
Charges (p.e.) in the camera
extra_noise_in_dim_pixels: `float`
Mean additional number of p.e. to be added (Poisson noise) to
pixels with charge below transition_charge. To be tuned by
comparing the starting MC and data
extra_bias_in_dim_pixels: `float`
Mean bias (w.r.t. original charge) of the new charge in pixels.
Should be 0 for non-peak-search pulse integrators. To be tuned by
comparing the starting MC and data
transition_charge: `float`
Border between "dim" and "bright" pixels. To be tuned by
comparing the starting MC and data
extra_noise_in_bright_pixels: `float`
Mean additional number of p.e. to be added (Poisson noise) to
pixels with charge above transition_charge. This is unbiased,
i.e. Poisson noise is introduced, and its average subtracted,
so that the mean charge in bright pixels remains unaltered.
This is because we assume that above transition_charge the
integration window is determined by the Cherenkov light, and
would not be modified by the additional NSB noise (presumably
small compared to the C-light). To be tuned by
comparing the starting MC and data
Returns
-------
image: `np.ndarray`
Modified (noisier) image
"""
bright_pixels = image > transition_charge
noise = np.where(bright_pixels, extra_noise_in_bright_pixels,
extra_noise_in_dim_pixels)
bias = np.where(bright_pixels, -extra_noise_in_bright_pixels,
extra_bias_in_dim_pixels - extra_noise_in_dim_pixels)
image = image + rng.poisson(noise) + bias
return image
@njit(cache=True)
def set_numba_seed(seed):
np.random.seed(seed)
@njit(cache=True)
def random_psf_smearer(image, fraction, indices, indptr):
"""
Random PSF smearer
Parameters
----------
image: `np.ndarray`
Charges (p.e.) in the camera
indices : `camera_geometry.neighbor_matrix_sparse.indices`
Pixel indices.
indptr : camera_geometry.neighbor_matrix_sparse.indptr
fraction: `float`
Fraction of the light in a pixel that will be distributed among its
immediate surroundings, i.e. immediate neighboring pixels, according
to Poisson statistics. Some light is lost for pixels which are at
the camera edge and hence don't have all possible neighbors
Returns
-------
new_image: `np.ndarray`
Modified (smeared) image
"""
new_image = image.copy()
for pixel in range(len(image)):
if image[pixel] <= 0:
continue
to_smear = np.random.poisson(image[pixel] * fraction)
if to_smear == 0:
continue
# remove light from current pixel
new_image[pixel] -= to_smear
# add light to neighbor pixels
neighbors = indices[indptr[pixel]: indptr[pixel + 1]]
n_neighbors = len(neighbors)
# all neighbors are equally likely to receive the charge
# we always distribute the charge into 6 neighbors, so that charge
# on the edges of the camera is lost
neighbor_charges = np.random.multinomial(to_smear, SMEAR_PROBABILITIES)
for n in range(n_neighbors):
neighbor = neighbors[n]
new_image[neighbor] += neighbor_charges[n]
return new_image
def calculate_noise_parameters(simtel_filename, data_dl1_filename,
config_filename=None):
"""
Calculates the parameters needed to increase the noise in an MC DL1 file
to match the noise in a real data DL1 file, using add_noise_in_pixels
The returned parameters are those needed by the function add_noise_in_pixels (see
description in its documentation above).
Parameters
----------
simtel_filename: `str`
a simtel file containing showers, from the same
production (same NSB and telescope settings) as the MC DL1 file below. It
must contain pixel-wise info on true number of p.e.'s from C-photons (
will be used to identify pixels which only contain noise).
data_dl1_filename: `str`
a real data DL1 file (processed with calibration
settings corresponding to those with which the MC is to be processed).
It must contain calibrated images, i.e. "DL1a" data. This file has the
"target" noise which we want to have in the MC files, for better
agreement of data and simulations.
config_filename: `str`
configuration file containing the calibration
settings used for processing both the data and the MC files above
Returns
-------
extra_noise_in_dim_pixels: `float`
Extra noise of dim pixels.
extra_bias_in_dim_pixels: `float`
Extra bias of dim pixels.
extra_noise_in_bright_pixels: `float`
Extra noise of bright pixels
"""
log.setLevel(logging.INFO)
if config_filename is None:
config = standard_config
else:
config = read_configuration_file(config_filename)
# Real data DL1 tables:
data_dl1_calibration = read_table(data_dl1_filename,
'/dl1/event/telescope/monitoring/calibration')
data_dl1_pedestal = read_table(data_dl1_filename,
'/dl1/event/telescope/monitoring/pedestal')
data_dl1_parameters = read_table(data_dl1_filename,
'/dl1/event/telescope/parameters/LST_LSTCam')
data_dl1_image = read_table(data_dl1_filename,
'/dl1/event/telescope/image/LST_LSTCam')
unusable = data_dl1_calibration['unusable_pixels']
# Locate pixels with HG declared unusable either in original calibration or
# in interleaved events:
bad_pixels = unusable[0][0] # original calibration
for tf in unusable[1:][0]: # calibrations with interleaveds
bad_pixels = np.logical_or(bad_pixels, tf)
good_pixels = ~bad_pixels
# First index: 1,2,... = values from interleaveds (0 is for original
# calibration run)
# Second index: 0 = high gain
# Third index: pixels
# HG adc to pe conversion factors from interleaved calibrations:
data_HG_dc_to_pe = data_dl1_calibration['dc_to_pe'][:, 0, :]
# Pixel-wise pedestal standard deviation (for an unbiased extractor),
# in adc counts:
data_HG_ped_std = data_dl1_pedestal['charge_std'][1:, 0, :]
# indices which connect each pedestal calculation to a given calibration:
calibration_id = data_dl1_pedestal['calibration_id'][1:]
# convert pedestal st deviations to p.e.
dummy = []
for i, x in enumerate(data_HG_ped_std[:, ]):
dummy.append(x * data_HG_dc_to_pe[calibration_id[i],])
dummy = np.array(dummy)
# Average for all interleaved calibrations (in case there are more than one)
data_HG_ped_std_pe = np.mean(dummy, axis=0) # one value per pixel
# Identify noisy pixels, likely containing stars - we want to adjust MC to
# the average diffuse NSB across the camera
data_median_std_ped_pe = np.median(data_HG_ped_std_pe)
data_std_std_ped_pe = np.std(data_HG_ped_std_pe)
log.info(f'Real data: median across camera of good pixels\' pedestal std '
f'{data_median_std_ped_pe:.3f} p.e.')
brightness_limit = data_median_std_ped_pe + 3 * data_std_std_ped_pe
too_bright_pixels = (data_HG_ped_std_pe > brightness_limit)
log.info(f'Number of pixels beyond 3 std dev of median: '
f'{too_bright_pixels.sum()}, (above {brightness_limit:.2f} p.e.)')
ped_mask = data_dl1_parameters['event_type'] == 2
# The charges in the images below are obtained with the extractor for
# showers, usually a biased one, like e.g. LocalPeakWindowSum
data_ped_charges = data_dl1_image['image'][ped_mask]
# Exclude too bright pixels, besides those with unusable calibration:
good_pixels &= ~too_bright_pixels
# recalculate the median of the pixels' std dev, with good_pixels:
data_median_std_ped_pe = np.median(data_HG_ped_std_pe[good_pixels])
log.info(f'Good and not too bright pixels: {good_pixels.sum()}')
# all_good is an events*pixels boolean array of valid signals:
all_good = np.reshape(np.tile(good_pixels, data_ped_charges.shape[0]),
data_ped_charges.shape)
# histogram of pedestal charges (biased extractor) from good and not noisy
# pixels:
qbins = 100
qrange = (-10, 15)
dataq = np.histogram(data_ped_charges[all_good].flatten(), bins=qbins,
range=qrange, density=True)
# Find the peak of the pedestal biased charge distribution of real data.
# Use an interpolated version of the histogram, for robustness:
func = interp1d(0.5*(dataq[1][1:]+dataq[1][:-1]), dataq[0],
kind='quadratic', fill_value='extrapolate')
xx = np.linspace(qrange[0], qrange[1], 100*qbins)
mode_data = xx[np.argmax(func(xx))]
# Event reader for simtel file:
mc_reader = EventSource(input_url=simtel_filename, config=Config(config))
# Obtain the configuration with which the pedestal calculations were
# performed:
ped_config = config['LSTCalibrationCalculator']['PedestalIntegrator']
tel_id = ped_config['tel_id']
# Obtain the (unbiased) extractor used for pedestal calculations:
pedestal_extractor_type = ped_config['charge_product']
pedestal_calibrator = CameraCalibrator(
image_extractor_type=pedestal_extractor_type,
config=Config(ped_config),
subarray=mc_reader.subarray
)
# Obtain the (usually biased) extractor used for shower images:
shower_extractor_type = config['image_extractor']
shower_calibrator = CameraCalibrator(
image_extractor_type=shower_extractor_type,
config=Config(config),
subarray=mc_reader.subarray
)
# Since these extractors are now for use on MC, we have to apply the pulse
# integration correction (in data that is currently, as of
# lstchain v0.7.5, replaced by an empirical (hard-coded) correction of the
# adc to pe conversion factors )
pedestal_calibrator.image_extractors[ped_config['charge_product']].apply_integration_correction = True
shower_calibrator.image_extractors[shower_extractor_type].apply_integration_correction = True
# Pulse integration window width of the (biased) extractor for showers:
shower_extractor_window_width = config[config['image_extractor']]['window_width']
# Pulse integration window width for the pedestal estimation:
pedestal_extractor_config = ped_config[pedestal_extractor_type]
pedestal_extractor_window_width = pedestal_extractor_config['window_width']
# MC pedestals integrated with the unbiased pedestal extractor
mc_ped_charges = []
# MC pedestals integrated with the biased shower extractor
mc_ped_charges_biased = []
for event in mc_reader:
if tel_id not in event.trigger.tels_with_trigger:
continue
# Extract the signals as we do for pedestals (unbiased fixed window
# extractor):
pedestal_calibrator(event)
charges = event.dl1.tel[tel_id].image
# True number of pe's from Cherenkov photons (to identify noise-only pixels)
true_image = event.simulation.tel[tel_id].true_image
mc_ped_charges.append(charges[true_image == 0])
# Now extract the signal as we would do for shower events (usually
# with a biased extractor, e.g. LocalPeakWindowSum):
shower_calibrator(event)
charges_biased = event.dl1.tel[tel_id].image
mc_ped_charges_biased.append(charges_biased[true_image == 0])
# All pixels behave (for now) in the same way in MC, just put them together
mc_ped_charges = np.concatenate(mc_ped_charges)
mc_ped_charges_biased = np.concatenate(mc_ped_charges_biased)
mcq = np.histogram(mc_ped_charges_biased, bins=qbins, range=qrange,
density=True)
# Find the peak of the pedestal biased charge distribution of MC. Use
# an interpolated version of the histogram, for robustness:
func = interp1d(0.5*(mcq[1][1:]+mcq[1][:-1]), mcq[0],
kind='quadratic', fill_value='extrapolate')
xx = np.linspace(qrange[0], qrange[1], 100*qbins)
mode_mc = xx[np.argmax(func(xx))]
mc_unbiased_std_ped_pe = np.std(mc_ped_charges)
# Find the additional noise (in data w.r.t. MC) for the unbiased extractor,
# and scale it to the width of the window for integration of shower images.
# The idea is that when a strong signal is present, the biased extractor
# will integrate around it, and the additional noise is unbiased because
# it won't modify the integration range.
extra_noise_in_bright_pixels = \
((data_median_std_ped_pe**2 - mc_unbiased_std_ped_pe**2) *
shower_extractor_window_width / pedestal_extractor_window_width)
# Just in case, makes sure we just add noise if the MC noise is smaller
# than the real data's:
extra_noise_in_bright_pixels = max(0., extra_noise_in_bright_pixels)
bias = mode_data - mode_mc
extra_bias_in_dim_pixels = max(bias, 0)
# differences of values to peak charge:
dq = data_ped_charges[all_good].flatten() - mode_data
dqmc = mc_ped_charges_biased - mode_mc
# maximum distance (in pe) from peak, to avoid strong impact of outliers:
maxq = 10
# calculate widening of the noise bump:
added_noise = (np.sum(dq[dq<maxq]**2)/len(dq[dq<maxq]) -
np.sum(dqmc[dqmc<maxq]**2)/len(dqmc[dqmc < maxq]))
added_noise = (max(0, added_noise))**0.5
extra_noise_in_dim_pixels = added_noise
return extra_noise_in_dim_pixels, extra_bias_in_dim_pixels, \
extra_noise_in_bright_pixels
def tune_nsb_on_waveform(waveform, added_nsb_fraction, original_nsb,
dt, pulse_templates, gain, charge_spe_cumulative_pdf):
"""
Inject single photon pulses in existing R1 waveforms to increase NSB.
Parameters
----------
waveform: charge (p.e. / ns) in each pixel and sampled time
added_nsb_fraction: fraction of the original NSB in simulation to be added
original_nsb: original NSB rate (astropy unit Hz)
dt: time between waveform samples (astropy unit s)
pulse_templates: `lstchain.data.NormalizedPulseTemplate` containing
the single p.e. pulse template used for the injection
gain: gain channel identifier for each pixel
charge_spe_cumulative_pdf: `scipy.interpolate.interp1d` Single p.e. gain
fluctuation cumulative pdf used to randomise the normalisation of
injected pulses
"""
n_pixels, n_samples = waveform.shape
duration = (20 + n_samples) * dt # TODO check needed time window, effect of edges
t = np.arange(-20, n_samples) * dt.value
mean_added_nsb = (added_nsb_fraction * original_nsb) * duration
rng = np.random.default_rng()
additional_nsb = rng.poisson(mean_added_nsb, n_pixels)
added_nsb_time = rng.uniform(-20 * dt.value, -20 * dt.value + duration.value, (n_pixels, max(additional_nsb)))
added_nsb_amp = charge_spe_cumulative_pdf(rng.uniform(size=(n_pixels, max(additional_nsb))))
baseline_correction = (added_nsb_fraction * original_nsb * dt).value
waveform -= baseline_correction
for i in range(n_pixels):
for j in range(additional_nsb[i]):
waveform[i] += (added_nsb_amp[i][j]
* (pulse_templates(t[20:] - added_nsb_time[i][j], 'HG' if gain[i] else 'LG')))
def calculate_required_additional_nsb(simtel_filename, data_dl1_filename, config=None):
# TODO check if good estimation
# TODO reduce duplicated code with 'calculate_noise_parameters'
"""
Calculates the additional NSB needed in the MC waveforms
to match a real data DL1 file
Parameters
----------
simtel_filename: a simtel file containing showers, from the production
(same NSB and telescope settings) as the one on which the correction will
be applied. It must contain pixel-wise info on true number of p.e.'s from
C-photons (will be used to identify pixels which only contain noise).
data_dl1_filename: a real data DL1 file (processed with calibration
settings corresponding to those with which the MC is to be processed).
It must contain calibrated images, i.e. "DL1a" data. This file has the
"target" NSB which we want to have in the MC files, for better
agreement of data and simulations.
config: configuration containing the calibration
settings used for processing both the data and the MC files above
Returns
-------
extra_nsb: Fraction of the additional NSB in data compared to MC.
data_ped_variance: Pedestal variance from data
mc_ped_variance: Pedestal variance from MC
"""
log.setLevel(logging.INFO)
if config is None:
config = standard_config
# Real data DL1 tables:
data_dl1_calibration = read_table(data_dl1_filename,
'/dl1/event/telescope/monitoring/calibration')
data_dl1_pedestal = read_table(data_dl1_filename,
'/dl1/event/telescope/monitoring/pedestal')
unusable = data_dl1_calibration['unusable_pixels']
# Locate pixels with HG declared unusable either in original calibration or
# in interleaved events:
bad_pixels = unusable[0][0] # original calibration
for tf in unusable[1:][0]: # calibrations with interleaved
bad_pixels = np.logical_or(bad_pixels, tf)
good_pixels = ~bad_pixels
# First index: 1,2,... = values from interleaved (0 is for original
# calibration run)
# Second index: 0 = high gain
# Third index: pixels
# HG adc to pe conversion factors from interleaved calibrations:
data_HG_dc_to_pe = data_dl1_calibration['dc_to_pe'][:, 0, :]
# Pixel-wise pedestal standard deviation (for an unbiased extractor),
# in adc counts:
data_HG_ped_std = data_dl1_pedestal['charge_std'][1:, 0, :]
# indices which connect each pedestal calculation to a given calibration:
calibration_id = data_dl1_pedestal['calibration_id'][1:]
# convert pedestal st deviations to p.e.
dummy = []
for i, x in enumerate(data_HG_ped_std[:, ]):
dummy.append(x * data_HG_dc_to_pe[calibration_id[i],])
dummy = np.array(dummy)
# Average for all interleaved calibrations (in case there are more than one)
data_HG_ped_std_pe = np.mean(dummy, axis=0) # one value per pixel
# Identify noisy pixels, likely containing stars - we want to adjust MC to
# the average diffuse NSB across the camera
data_median_std_ped_pe = | np.median(data_HG_ped_std_pe) | numpy.median |
'''
------------------------------------------------------------------------
Last updated 7/13/2015
Functions for generating omega, the T x S array which describes the
demographics of the population
This py-file calls the following other file(s):
utils.py
data\demographic\demographic_data.csv
data\demographic\mortality_rates.csv
This py-file creates the following other file(s):
(make sure that an OUTPUT folder exists)
OUTPUT/fert_rates.png
OUTPUT/mort_rates.png
OUTPUT/survival_rate.png
OUTPUT/cum_mort_rate.png
OUTPUT/imm_rates.png
OUTPUT/Population.png
OUTPUT/Population_growthrate.png
OUTPUT/omega_init.png
OUTPUT/omega_ss.png
------------------------------------------------------------------------
'''
'''
------------------------------------------------------------------------
Packages
------------------------------------------------------------------------
'''
import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import numpy.polynomial.polynomial as poly
import scipy.optimize as opt
import utils
cur_path = os.path.split(os.path.abspath(__file__))[0]
DEMO_DIR = os.path.join(cur_path, "data", "demographic")
pd.options.mode.chained_assignment = None
'''
------------------------------------------------------------------------
Import data sets
------------------------------------------------------------------------
Population data:
Obtained from:
Annual Estimates of the Resident Population by Single Year of
Age and Sex: April 1, 2010 to July 1, 2013
(Both sexes)
National Characteristics, Vintage 2013
US Census Bureau
http://www.census.gov/popest/data/national/asrh/2013/index.html
Mortality rates data:
Obtained from:
Male and Female death probabilities
Actuarial Life table, 2010
Social Security Administration
http://www.ssa.gov/oact/STATS/table4c6.html
Fertility rates data:
Obtained from:
Births and birth rates, by age of mother, US, 2010
National Vital Statistics Reports, CDC
http://www.cdc.gov/nchs/data/nvsr/nvsr60/nvsr60_02.pdf
Since rates are per 1000 women, the data is divided by 1000
------------------------------------------------------------------------
'''
# Population data
demo_file = utils.read_file(cur_path, "data/demographic/demographic_data.csv")
data = pd.read_table(demo_file, sep=',', header=0)
data = data.set_index('Age')
# Remove commas in the data
for index, value in enumerate(data['2010']):
data['2010'][index] = int(value.replace(',', ''))
for index, value in enumerate(data['2011']):
data['2011'][index] = int(value.replace(',', ''))
for index, value in enumerate(data['2012']):
data['2012'][index] = int(value.replace(',', ''))
for index, value in enumerate(data['2013']):
data['2013'][index] = int(value.replace(',', ''))
# Create a copy of the data to be used elsewhere, without changing the
# main data
data_raw = data.copy(deep=True)
# Mortality rates data
#mort_data = pd.read_table(os.path.join(DEMO_DIR, 'mortality_rates.csv'), sep=',')
mort_file = utils.read_file(cur_path, "data/demographic/mortality_rates.csv")
mort_data = pd.read_table(mort_file, sep=',')
# Remove commas in the data
for index, value in enumerate(mort_data['male_weight']):
mort_data['male_weight'][index] = float(value.replace(',', ''))
for index, value in enumerate(mort_data['female_weight']):
mort_data['female_weight'][index] = float(value.replace(',', ''))
# Average male and female death rates
mort_data['mort_rate'] = (
(np.array(mort_data.male_death.values).astype(float) * np.array(
mort_data.male_weight.values).astype(float)) + (np.array(
mort_data.female_death.values).astype(float) * np.array(
mort_data.female_weight.values).astype(float))) / (
np.array(mort_data.male_weight.values).astype(float) + np.array(
mort_data.female_weight.values).astype(float))
mort_data = mort_data[mort_data.mort_rate.values < 1]
del mort_data['male_death'], mort_data[
'female_death'], mort_data['male_weight'], mort_data[
'female_weight'], mort_data['male_expectancy'], mort_data[
'female_expectancy']
# As the data gives the probability of death, one minus the rate will
# give the survial rate
mort_data['surv_rate'] = 1 - mort_data.mort_rate
# Create an array of death rates of children
# Fertility rates data
fert_data = np.array(
[.4, 34.3, 17.3, 58.3, 90.0, 108.3, 96.6, 45.9, 10.2, .7]) / 1000
# Fertility rates are given in age groups of 5 years, so the following
# are the midpoints of those groups
age_midpoint = np.array([12, 17, 16, 18.5, 22, 27, 32, 37, 42, 49.5])
'''
------------------------------------------------------------------------
Define functions
------------------------------------------------------------------------
'''
def fit_exp_right(params, point1, point2):
# Fit exponentials to two points for right tail of distributions
a, b = params
x1, y1 = point1
x2, y2 = point2
error1 = a*b**(-x1) - y1
error2 = a*b**(-x2) - y2
return [error1, error2]
def fit_exp_left(params, point1, point2):
# Fit exponentials to two points for left tail of distributions
a, b = params
x1, y1 = point1
x2, y2 = point2
error1 = a*b**(x1) - y1
error2 = a*b**(x2) - y2
return [error1, error2]
def exp_int(points, a, b):
top = a * ((1.0/(b**40)) - b**(-points))
bottom = np.log(b)
return top / bottom
def integrate(func, points):
params_guess = [1, 1]
a, b = opt.fsolve(fit_exp_right, params_guess, args=(
[40, poly.polyval(40, func)], [49.5, .0007]))
func_int = poly.polyint(func)
integral = np.empty(points.shape)
integral[points <= 40] = poly.polyval(points[points <= 40], func_int)
integral[points > 40] = poly.polyval(40, func_int) + exp_int(
points[points > 40], a, b)
return np.diff(integral)
'''
------------------------------------------------------------------------
Survival Rates
------------------------------------------------------------------------
'''
def get_survival(S, starting_age, ending_age, E):
'''
Parameters:
S - Number of age cohorts (scalar)
starting_age = initial age of cohorts (scalar)
ending_age = ending age of cohorts (scalar)
E = number of children (scalar)
Returns:
surv_array - S x 1 array of survival rates for each age cohort
children_rate - starting_age x 1 array of survival
rates for children
'''
mort_rate = np.array(mort_data.mort_rate)
mort_poly = poly.polyfit(np.arange(mort_rate.shape[0]), mort_rate, deg=18)
mort_int = poly.polyint(mort_poly)
child_rate = poly.polyval(np.linspace(0, starting_age, E+1), mort_int)
child_rate = np.diff(child_rate)
mort_rate = poly.polyval(
np.linspace(starting_age, ending_age, S+1), mort_int)
mort_rate = np.diff(mort_rate)
child_rate[child_rate < 0] = 0.0
mort_rate[mort_rate < 0] = 0.0
return 1.0 - mort_rate, 1.0 - child_rate
'''
------------------------------------------------------------------------
Immigration Rates
------------------------------------------------------------------------
'''
pop_2010, pop_2011, pop_2012, pop_2013 = np.array(
data_raw['2010'], dtype='f'), np.array(
data_raw['2011'], dtype='f'), np.array(
data_raw['2012'], dtype='f'), np.array(
data_raw['2013'], dtype='f')
def get_immigration1(S, starting_age, ending_age, pop_2010, pop_2011, E):
'''
Parameters:
S - Number of age cohorts
starting_age - initial age of cohorts
pop1 - initial population
pop2 - population one year later
Returns:
im_array - S+E x 1 array of immigration rates for each
age cohort
'''
# Get survival rates for the S age groups
surv_array, children_rate = get_survival(
ending_age-starting_age, starting_age, ending_age, starting_age)
surv_array = np.array(list(children_rate) + list(surv_array))
# Only keep track of individuals in 2010 that don't die
pop_2010 = pop_2010[:ending_age]
# In 2011, individuals will have aged one year
pop_2011 = pop_2011[1:ending_age+1]
# The immigration rate will be 1 plus the percent change in
# population (since death has already been accounted for)
perc_change = ((pop_2011 - pop_2010) / pop_2010)
# Remove the last entry, since individuals in the last period will die
im_array = perc_change - (surv_array - 1)
return im_array
def get_immigration2(S, starting_age, ending_age, E):
'''
Parameters:
S - Number of age cohorts
starting age - initial age of cohorts
Returns:
im_array - S x 1 array of immigration rates for each
age cohort
child_imm_rate - starting_age x 1 array of immigration
rates for children
'''
imm_rate_condensed1 = get_immigration1(
S, starting_age, ending_age, pop_2010, pop_2011, E)
imm_rate_condensed2 = get_immigration1(
S, starting_age, ending_age, pop_2011, pop_2012, E)
imm_rate_condensed3 = get_immigration1(
S, starting_age, ending_age, pop_2012, pop_2013, E)
im_array = (
imm_rate_condensed1 + imm_rate_condensed2 + imm_rate_condensed3) / 3.0
poly_imm = poly.polyfit(np.linspace(
1, ending_age, ending_age-1), im_array[:-1], deg=18)
poly_imm_int = poly.polyint(poly_imm)
child_imm_rate = poly.polyval(np.linspace(
0, starting_age, E+1), poly_imm_int)
imm_rate = poly.polyval(np.linspace(
starting_age, ending_age, S+1), poly_imm_int)
child_imm_rate = np.diff(child_imm_rate)
imm_rate = np.diff(imm_rate)
imm_rate[-1] = 0.0
return imm_rate, child_imm_rate
'''
------------------------------------------------------------------------
Fertility Rates
------------------------------------------------------------------------
'''
def get_fert(S, starting_age, ending_age, E):
'''
Parameters:
S - Number of age cohorts
starting age - initial age of cohorts
Returns:
fert_rate - Sx1 array of fertility rates for each
age cohort
children_fertrate - starting_age x 1 array of zeros, to be
used in get_omega()
'''
# Fit a polynomial to the fertility rates
poly_fert = poly.polyfit(age_midpoint, fert_data, deg=4)
fert_rate = integrate(poly_fert, np.linspace(
starting_age, ending_age, S+1))
fert_rate /= 2.0
children_fertrate_int = poly.polyint(poly_fert)
children_fertrate_int = poly.polyval(np.linspace(
0, starting_age, E + 1), children_fertrate_int)
children_fertrate = np.diff(children_fertrate_int)
children_fertrate /= 2.0
children_fertrate[children_fertrate < 0] = 0
children_fertrate[:int(10*S/float(ending_age-starting_age))] = 0
return fert_rate, children_fertrate
'''
------------------------------------------------------------------------
Generate graphs of mortality, fertility, and immigration rates
------------------------------------------------------------------------
'''
def rate_graphs(S, starting_age, ending_age, imm, fert, surv, child_imm,
child_fert, child_mort, output_dir="./OUTPUT"):
domain = np.arange(child_fert.shape[0] + S) + 1
mort = mort_data.mort_rate
domain2 = np.arange(mort.shape[0]) + 1
domain4 = np.arange(child_imm.shape[0] + imm.shape[0]) + 1
# Graph of fertility rates
plt.figure()
plt.plot(
domain, list(child_fert)+list(fert), linewidth=2, color='blue')
plt.xlabel(r'age $s$')
plt.ylabel(r'fertility $f_s$')
fert_rates = os.path.join(output_dir, "Demographics/fert_rates")
plt.savefig(fert_rates)
# Graph of mortality rates
plt.figure()
plt.plot(domain2[:ending_age-1], (1-np.array(list(child_mort)+list(surv)))[:-1], color='blue', linewidth=2)
plt.plot(domain2[ending_age:], mort[
ending_age:], color='blue', linestyle='--', linewidth=2)
plt.axvline(x=ending_age, color='red', linestyle='-', linewidth=1)
plt.xlabel(r'age $s$')
plt.ylabel(r'mortality $\rho_s$')
mort_rates = os.path.join(output_dir, "Demographics/mort_rates")
plt.savefig(mort_rates)
cum_surv_arr = np.cumprod(surv)
domain3 = np.arange(surv.shape[0]) + 1
# Graph of cumulative mortality rates
plt.figure()
plt.plot(domain3, cum_surv_arr)
plt.xlabel(r'age $s$')
plt.ylabel(r'survival rate $1-\rho_s$')
surv_rates = os.path.join(output_dir, "Demographics/survival_rates")
plt.savefig(surv_rates)
cum_mort_rate = 1-cum_surv_arr
plt.figure()
plt.plot(domain3, cum_mort_rate)
plt.xlabel(r'age $s$')
plt.ylabel(r'cumulative mortality rate')
cum_mort_rates = os.path.join(output_dir, "Demographics/cum_mort_rate")
plt.savefig(cum_mort_rates)
# Graph of immigration rates
plt.figure()
plt.plot(domain4, list(
child_imm)+list(imm), linewidth=2, color='blue')
plt.xlabel(r'age $s$')
plt.ylabel(r'immigration $i_s$')
imm_rates = os.path.join(output_dir, "Demographics/imm_rates")
plt.savefig(imm_rates)
'''
------------------------------------------------------------------------
Generate graphs of Population
------------------------------------------------------------------------
'''
def pop_graphs(S, T, starting_age, ending_age, children, g_n, omega,
output_dir="./OUTPUT"):
N = omega[T].sum() + children[T].sum()
x = children.sum(1) + omega.sum(1)
x2 = 100 * np.diff(x)/x[:-1]
plt.figure()
plt.plot(np.arange(T+S)+1, x, 'b', linewidth=2)
plt.title('Population Size (as a percent of the initial population)')
plt.xlabel(r'Time $t$')
# plt.ylabel('Population size, as a percent of initial population')
pop = os.path.join(output_dir, "Demographics/imm_rates")
plt.savefig(pop)
plt.figure()
plt.plot(np.arange(T+S-1)+1, x2, 'b', linewidth=2)
plt.axhline(y=100 * g_n, color='r', linestyle='--', label=r'$\bar{g}_n$')
plt.legend(loc=0)
plt.xlabel(r'Time $t$')
plt.ylabel(r'Population growth rate $g_n$')
# plt.title('Population Growth rate over time')
pop_growth = os.path.join(output_dir, "Demographics/Population_growthrate")
plt.savefig(pop_growth)
plt.figure()
plt.plot(np.arange(S+int(starting_age * S / (
ending_age-starting_age)))+1, list(
children[0, :]) + list(
omega[0, :]), linewidth=2, color='blue')
plt.xlabel(r'age $s$')
plt.ylabel(r'$\omega_{s,1}$')
omega_init = os.path.join(output_dir, "Demographics/omega_init")
plt.savefig(omega_init)
plt.figure()
plt.plot(np.arange(S+int(starting_age * S / (
ending_age-starting_age)))+1, list(
children[T, :]/N) + list(
omega[T, :]/N), linewidth=2, color='blue')
plt.xlabel(r'age $s$')
plt.ylabel(r'$\overline{\omega}$')
omega_ss = os.path.join(output_dir, "Demographics/omega_ss")
plt.savefig(omega_ss)
'''
------------------------------------------------------------------------
Generate Demographics
------------------------------------------------------------------------
'''
def get_omega(S, T, starting_age, ending_age, E, flag_graphs):
'''
Inputs:
S - Number of age cohorts (scalar)
T - number of time periods in TPI (scalar)
starting_age - initial age of cohorts (scalar)
ending_age = ending age of cohorts (scalar)
E = number of children (scalar)
flag_graphs = graph variables or not (bool)
Outputs:
omega_big = array of all population weights over time ((T+S)x1 array)
g_n_SS = steady state growth rate (scalar)
omega_SS = steady state population weights (Sx1 array)
surv_array = survival rates (Sx1 array)
rho = mortality rates (Sx1 array)
g_n_vec = population growth rate over time ((T+S)x1 array)
'''
data1 = data
pop_data = np.array(data1['2010'])
poly_pop = poly.polyfit(np.linspace(
0, pop_data.shape[0]-1, pop_data.shape[0]), pop_data, deg=11)
poly_int_pop = poly.polyint(poly_pop)
pop_int = poly.polyval(np.linspace(
starting_age, ending_age, S+1), poly_int_pop)
new_omega = pop_int[1:]-pop_int[:-1]
surv_array, children_rate = get_survival(S, starting_age, ending_age, E)
surv_array[-1] = 0.0
imm_array, children_im = get_immigration2(S, starting_age, ending_age, E)
#imm_array *= 0.0
#children_im *= 0.0
fert_rate, children_fertrate = get_fert(S, starting_age, ending_age, E)
cum_surv_rate = | np.cumprod(surv_array) | numpy.cumprod |
from mikkel_tools.MiClass import MiClass
import mikkel_tools.utility as mt_util
import matplotlib.pyplot as plt
import pyshtools
import scipy.linalg as spl
import pickle
import numpy as np
import mikkel_tools.GMT_tools as gt
import os
#import utility as sds_util
class SDSS(MiClass):
""" Class for performing spherical direct sequential simulation """
def __init__(self, comment, N_SH = 60, sim_type = "core", sat_height = 350, N_SH_secondary = None):
super().__init__(sat_height = sat_height)
self.comment = comment
self.class_abs_path = os.path.dirname(__file__)
# Initial constants related to spherical harmonics and Earth system size.
self.N_SH = N_SH
self.N_SH_secondary = N_SH_secondary
self.sim_type = sim_type
def make_grid(self, r_grid, grid, calc_sph_d = False, N_grid = 1000):
# Initialize
self.r_grid = r_grid
self.grid = grid
self.sph_d = None
# Generate equal area grid
if isinstance(grid,str):
self.N_grid = N_grid
N_grid_orig = self.N_grid
check_flag = False
if grid == "equal_area":
while check_flag is False:
points_polar = mt_util.eq_point_set_polar(self.N_grid) # Compute grid with equal area grid functions
# Set lat and lon from estimated grid
self.lon = points_polar[:,0]*180/np.pi
self.lat = 90 - points_polar[:,1]*180/np.pi
# Determine equal area grid specifics used for defining the integration area
s_cap, n_regions = mt_util.eq_caps(self.N_grid)
self.n_regions = n_regions.T
self.s_cap = s_cap
if self.N_grid == int(np.sum(n_regions)):
check_flag = True
if N_grid_orig - self.N_grid != 0:
print("")
print("___ CHANGES TO GRID ___")
print("N = {}, not compatible for equal area grid".format(N_grid_orig))
print("N has been set to {}".format(self.N_grid))
else:
self.N_grid -= 1
self.handle_poles()
# Generate Gauss-Legendre quadrature grid
elif grid == "gauss_leg":
self.gauss_leg_n_from_N = int(np.ceil(np.sqrt(self.N_grid/2))) # Approximate required Gauss-Legendre grid size from defined N_grid
gauss_leg = np.polynomial.legendre.leggauss(self.gauss_leg_n_from_N) # Use built-in numpy function to generate grid
# Set lat and lon range from estimated grid
lat = 90-np.flipud(np.arccos(gauss_leg[0]).reshape(-1,1))*180/np.pi
lon = np.arange(0,2*np.pi,np.pi/self.gauss_leg_n_from_N)*180/np.pi
weights, none = np.meshgrid(gauss_leg[1],lon,indexing='ij') # Get weights for quadrature on grid
self.weights = np.ravel(weights)
# Compute full lat/lon grid
lat, lon = np.meshgrid(lat,lon,indexing='ij')
self.lon = lon.ravel()
self.lat = lat.ravel()
self.N_grid = 2*self.gauss_leg_n_from_N**2 # Update N_grid
# Generate Lebedev quadrature grid
elif grid == "lebedev":
import quadpy
# Lebedev grid generation from quadpy is limited to the following two choices
if self.N_grid >= 5000:
scheme = quadpy.sphere.lebedev_131()
else:
scheme = quadpy.sphere.lebedev_059()
# Set lat and lon from estimated grid
coords = scheme.azimuthal_polar
self.lon = 180+coords[:,0]*180/np.pi
self.lat = 90-coords[:,1]*180/np.pi
self.weights = np.ravel(scheme.weights) # Get weights for quadrature on grid
self.N_grid = len(self.weights) # Update N_grid according to Lebedev grid
else:
self.lon = grid[:,0]
self.lat = grid[:,1]
self.N_grid = len(self.lon)
# Compute spherical distances between all points on grid if required
if calc_sph_d is True:
lon_mesh, lat_mesh = np.meshgrid(self.lon, self.lat, indexing='ij')
self.sph_d = mt_util.haversine(self.r_grid, lon_mesh, lat_mesh, lon_mesh.T, lat_mesh.T)
def handle_poles(self):
import numpy as np
# Remove the first and last grid points (the poles) and the corresponding structure related components
idx_end_core = self.N_grid-1
self.lat = np.delete(self.lat,[0,idx_end_core],0)
self.lon = np.delete(self.lon,[0,idx_end_core],0)
self.N_grid = idx_end_core-1
self.n_regions = np.delete(self.n_regions,-1,1)
self.n_regions = np.delete(self.n_regions,0,1)
self.s_cap = np.delete(self.s_cap,-1,0)
self.s_cap = np.delete(self.s_cap,0,0)
self.N_grid = idx_end_core-1
if self.sph_d is not None:
self.sph_d = np.delete(self.sph_d,[0,idx_end_core],0)
self.sph_d = np.delete(self.sph_d,[0,idx_end_core],1)
def data(self, *args):
# Generate design matrix for grid
A_r, A_theta, A_phi = gt.design_SHA(self.r_grid/self.a, (90.0-self.lat)*self.rad, self.lon*self.rad, self.N_SH)
G = np.vstack((A_r, A_theta, A_phi))
# Load Gauss coefficients from data files
if np.logical_or(self.sim_type == "core", self.sim_type == "sat"):
Gauss_in = np.loadtxt('mikkel_tools/models_shc/Julien_Gauss_JFM_E-8_snap.dat')
elif self.sim_type == "surface":
Gauss_in = np.loadtxt('mikkel_tools/models_shc/Masterton_13470_total_it1_0.glm')
else:
Gauss_in = np.loadtxt(args[0], comments='%')
# Compute Gauss coefficients as vector
g = mt_util.gauss_vector(Gauss_in, self.N_SH, i_n = 2, i_m = 3)
# Generate field data
#data_dynamo = np.matrix(G)*np.matrix(g).T
data_dynamo = np.matmul(G,g.T)
data = np.array(data_dynamo[:len(A_r)]).ravel()
self.data = np.zeros((self.N_grid,))
self.data = data.copy()
self.r_grid_repeat = np.ones(self.N_grid,)*self.r_grid
# Target statistics
self.target_var = np.var(self.data)
self.target_mean = 0.0
def load_swarm(self, dataset, use_obs = False, target_var = None, target_var_factor = None):
# Load swarm samples
data_swarm = {"SW_A":np.loadtxt("swarm_data/SW_A_AprilMayJune18_dark_quiet_NEC.txt",comments="%"), "SW_B":np.loadtxt("swarm_data/SW_B_AprilMayJune18_dark_quiet_NEC.txt",comments="%"), "SW_C":np.loadtxt("swarm_data/SW_C_AprilMayJune18_dark_quiet_NEC.txt",comments="%")}
if dataset == "A":
data_swarm = {"obs":data_swarm["SW_A"][:,13], "radius":data_swarm["SW_A"][:,1], "theta":(data_swarm["SW_A"][:,2]), "phi":data_swarm["SW_A"][:,3], "N":data_swarm["SW_A"][:,13].shape[0]}
elif dataset == "B":
data_swarm = {"obs":data_swarm["SW_B"][:,13], "radius":data_swarm["SW_B"][:,1], "theta":(data_swarm["SW_B"][:,2]), "phi":data_swarm["SW_B"][:,3], "N":data_swarm["SW_B"][:,13].shape[0]}
elif dataset == "C":
data_swarm = {"obs":data_swarm["SW_C"][:,13], "radius":data_swarm["SW_C"][:,1], "theta":(data_swarm["SW_C"][:,2]), "phi":data_swarm["SW_C"][:,3], "N":data_swarm["SW_C"][:,13].shape[0]}
elif dataset == "ABC":
data_swarm = {"obs":np.hstack((data_swarm["SW_A"][:,13],data_swarm["SW_B"][:,13],data_swarm["SW_C"][:,13])),
"radius":np.hstack((data_swarm["SW_A"][:,1],data_swarm["SW_B"][:,1],data_swarm["SW_C"][:,1])),
"theta":np.hstack(((data_swarm["SW_A"][:,2]),(data_swarm["SW_B"][:,2]),(data_swarm["SW_C"][:,2]))),
"phi":np.hstack((data_swarm["SW_A"][:,3],data_swarm["SW_B"][:,3],data_swarm["SW_C"][:,3])),
"N":np.hstack((data_swarm["SW_A"][:,13],data_swarm["SW_B"][:,13],data_swarm["SW_C"][:,13])).shape[0]}
self.grid_theta = data_swarm["theta"]
self.grid_phi = data_swarm["phi"]
self.grid_radial = data_swarm["radius"]
self.grid_obs = data_swarm["obs"]
self.grid_N = data_swarm["N"]
if use_obs == True:
self.data = self.grid_obs
# Target statistics
if target_var_factor is not None:
self.target_var = target_var_factor*np.var(self.data)
elif target_var == None:
self.target_var = np.var(self.data)
else:
self.target_var = target_var
self.target_mean_true = np.mean(self.data)
self.target_mean = 0.0
def generate_map(self, grid_type = "glq", target_var = None, target_var_factor = None, *args):
# Load Gauss coefficients from data files
if np.logical_or(self.sim_type == "core", self.sim_type == "sat"):
Gauss_in = np.loadtxt('mikkel_tools/models_shc/Julien_Gauss_JFM_E-8_snap.dat')
elif self.sim_type == "core_alt":
import hdf5storage
#g_ens = np.genfromtxt("mikkel_tools/models_shc/gnm_midpath.dat").T*10**9
g_ens = -(hdf5storage.loadmat("mikkel_tools/models_shc/Gauss_Bsurf_2021.mat")["gnm"].T)[:,:].copy()
self.ensemble_B(g_ens, nmax = self.N_SH, r_at = self.r_cmb, grid_type = "glq")
self.m_ens = self.B_ensemble[:,0,:].copy()[:,200:]
var_ens = np.var(self.m_ens, axis=0)
idx_close_to_var = np.argwhere(np.logical_and(var_ens>0.9995*np.mean(var_ens), var_ens<1.0005*np.mean(var_ens)))
g = np.ravel(g_ens[:,idx_close_to_var[-1]])
N_SH_max = self.N_SH
self.ens_idx = int(idx_close_to_var[-1])
elif self.sim_type == "core_ens":
g_ens = np.genfromtxt("mikkel_tools/models_shc/gnm_midpath.dat").T*10**9
g_ens = g_ens[:mt_util.shc_vec_len(self.N_SH),:]
self.ensemble_B(g_ens, nmax = self.N_SH, r_at = self.r_cmb, grid_type = "glq")
self.m_ens = self.B_ensemble[:,0,:].copy()[:,200:]
var_ens = np.var(self.m_ens, axis=0)
idx_close_to_var = np.argwhere(np.logical_and(var_ens>0.9995*np.mean(var_ens), var_ens<1.0005*np.mean(var_ens)))
g = np.ravel(g_ens[:,idx_close_to_var[-1]])
N_SH_max = self.N_SH
self.ens_idx = int(idx_close_to_var[-1])
#self.g_ens = g_ens
elif self.sim_type == "lith_ens":
#g_ens = np.load("mikkel_tools/models_shc/lithosphere_g_in_rotated.npy")
g_ens = np.load("mikkel_tools/models_shc/LiP_ensemble_N500_n120_p05_vary_crust.npy")
#self.lith_ens_cut = 100
#g_ens = g_ens[:mt_util.shc_vec_len(self.N_SH),::self.lith_ens_cut]
g_ens = g_ens[:mt_util.shc_vec_len(self.N_SH),:]
#R = mt_util.lowe_shspec(self.N_SH, self.a, self.a, g_ens)
#g_ens = g_ens[:,np.mean(R,axis=0)>5]
self.ensemble_B(g_ens, nmax = self.N_SH, r_at = self.a, grid_type = "glq")
self.m_ens = self.B_ensemble[:,0,:].copy()
var_ens = np.var(self.m_ens, axis=0)
idx_close_to_var = np.argwhere(np.logical_and(var_ens>0.95*np.mean(var_ens), var_ens<1.05*np.mean(var_ens)))
g = np.ravel(g_ens[:,idx_close_to_var[-1]])
N_SH_max = self.N_SH
self.ens_idx = int(idx_close_to_var[-1])
elif self.sim_type == "surface":
Gauss_in = np.loadtxt('mikkel_tools/models_shc/Masterton_13470_total_it1_0.glm')
elif self.sim_type == "separation":
Gauss_in_core = np.loadtxt('mikkel_tools/models_shc/Julien_Gauss_JFM_E-8_snap.dat')
Gauss_in_lithos = np.loadtxt('mikkel_tools/models_shc/Masterton_13470_total_it1_0.glm')
g_c = mt_util.gauss_vector(Gauss_in_core, self.N_SH, i_n = 2, i_m = 3)
g_l = mt_util.gauss_vector(Gauss_in_lithos, self.N_SH_secondary, i_n = 2, i_m = 3)
g_zip = (g_c,g_l)
idx_zip_min = np.argmin((g_c.shape[0],g_l.shape[0]))
idx_zip_max = np.argmax((g_c.shape[0],g_l.shape[0]))
g = g_zip[idx_zip_max].copy()
g[:g_zip[idx_zip_min].shape[0]] += g_zip[idx_zip_min]
N_SH_max = np.max((self.N_SH, self.N_SH_secondary))
else:
Gauss_in = np.loadtxt(args[0], comments='%')
if np.logical_and.reduce((self.sim_type != "separation", self.sim_type != "core_ens", self.sim_type != "lith_ens", self.sim_type != "core_alt")):
# Compute Gauss coefficients as vector
g = mt_util.gauss_vector(Gauss_in, self.N_SH, i_n = 2, i_m = 3)
N_SH_max = self.N_SH
# Generate field
self.ensemble_B(g, nmax = N_SH_max, N_mf = 2, mf = True, nmf = False, r_at = self.r_grid, grid_type = grid_type)
self.data = self.B_ensemble[:,0]
del self.B_ensemble
"""
if grid_type == "glq":
self.data = self.B_ensemble_glq[:,0]
del self.B_ensemble_glq
elif grid_type == "even":
self.data = self.B_ensemble_even[:,0]
del self.B_ensemble_even
elif grid_type == "eqa":
self.data = self.B_ensemble_eqa[:,0]
del self.B_ensemble_eqa
elif grid_type == "swarm":
self.data = self.B_ensemble_swarm[:,0]
"""
if grid_type != "swarm":
self.r_grid_repeat = np.ones(self.N_grid,)*self.r_grid
# Target statistics
if target_var_factor is not None:
self.target_var = target_var_factor*np.var(self.data)
elif target_var == None:
self.target_var = np.var(self.data)
else:
self.target_var = target_var
self.target_mean_true = np.mean(self.data)
self.target_mean = 0.0
self.g_prior = g
def condtab(self, normsize = 1001, model_hist = False, table = 'rough', quantiles = None,
rangn_lim = 3.5, rangn_N = 501, rangv_lim = 2.0, rangv_N = 101, rangn_geomspace = False):
"""
Conditional distribution table
"""
import numpy as np
from scipy.stats import norm, laplace
from sklearn.preprocessing import QuantileTransformer
# Linearly spaced value array with start/end very close to zero/one
start = 1e-16 #Python min
#start = 0.001
linspace = np.linspace(start,1-start,normsize)
# Possible model target histogram cdf/ccdf
if isinstance(model_hist, str) is False:
data_sorted = np.ravel(model_hist)
elif model_hist == True:
ag,bg = laplace.fit(self.data)
mod_data = np.random.laplace(ag,bg,size=100000)
#data_sorted = np.sort(mod_data)
data_sorted = mod_data
elif model_hist == "laplace":
rv = laplace()
self.data = laplace.rvs(loc = 0, scale=1, size=self.N_grid)
self.target_var = np.var(self.data)
self.target_mean = 0.0
#data_sorted = np.sort(self.data)
data_sorted = self.data
set_nmax = self.grid_nmax
C_cilm = pyshtools.expand.SHExpandGLQ(self.data.reshape(self.grid_nmax+1,2*self.grid_nmax+1), self.grid_w_shtools, self.grid_zero, [1, 1, set_nmax])
C_index = np.transpose(pyshtools.shio.SHCilmToCindex(C_cilm))
self.g_prior = mt_util.gauss_vector_zeroth(C_index, set_nmax, i_n = 0, i_m = 1)
self.g_cilm = C_cilm.copy()
elif model_hist == "ensemble":
data_sorted = np.ravel(self.m_ens)
data_sorted = data_sorted[0.5*np.max(np.abs(data_sorted))>np.abs(data_sorted)]
#data_sorted = np.delete(data_sorted, np.abs(data_sorted)>np.max(np.abs(data_sorted))*0.5)
else:
#data_sorted = np.sort(self.data)
data_sorted = self.data
if rangn_geomspace == False:
rangn = np.linspace(-rangn_lim,rangn_lim,rangn_N)
else:
rangn = np.vstack((np.geomspace(-rangn_lim,-start,int(rangn_N/2)).reshape(-1,1),np.zeros((1,1)),np.geomspace(start,rangn_lim,int(rangn_N/2)).reshape(-1,1)))
rangv = np.linspace(start,rangv_lim,rangv_N)
# Normscored local conditional distributions
# Initialize matrices
CQF_dist = np.zeros((len(rangn),len(rangv),len(linspace)))
CQF_mean = np.zeros((len(rangn),len(rangv)))
CQF_var = np.zeros((len(rangn),len(rangv)))
# Perform quantile transformation
if quantiles == None:
quantiles = int(0.1*len(data_sorted))
# QuantileTransformer setup
qt = QuantileTransformer(n_quantiles=quantiles, random_state=None, output_distribution='normal',subsample=10e8)
qt.fit(data_sorted.reshape(-1,1))
#vrg = qt.transform(data_sorted.reshape(-1,1))
# Generate CQF distributions, means, and variances
print("")
for i in range(0,len(rangn)):
for j in range(0,len(rangv)):
#CQF_dist[i,j,:] = np.sort(qt.inverse_transform((norm.ppf(linspace,loc=rangn[i],scale=np.sqrt(rangv[j]))).reshape(-1,1)).ravel(),axis=0)
CQF_dist[i,j,:] = qt.inverse_transform((norm.ppf(linspace,loc=rangn[i],scale=np.sqrt(rangv[j]))).reshape(-1,1)).ravel()
CQF_mean[i,j] = np.mean(CQF_dist[i,j,:],axis=0,dtype=np.float64)
CQF_var[i,j] = np.var(CQF_dist[i,j,:],axis=0,ddof=1,dtype=np.float64)
#CQF_var[i,j] = np.var(CQF_dist[i,j,:],axis=0,ddof=0,dtype=np.float64)
self.CQF_dist = CQF_dist
self.CQF_mean = CQF_mean
self.CQF_var = CQF_var
self.rangv = rangv
self.rangn = rangn
self.condtab_normsize = normsize
self.condtab_model_hist = model_hist
self.condtab_table = table
#condtab = {"target variance":target_var, "target variance_dat":target_var_dat, "target mean":target_mean, "target mean_dat":target_mean_dat, "QF norm range":rangn, "QF var range":rangv, "CQF dist":CQF_dist, "CQF mean":CQF_mean, "CQF var":CQF_var, "target normscore":vrg, "compiler":setup["condtab_compiler"], "normsize":normsize, "start":start}
def find_sort_d(self, max_dist = 2000):
import numpy as np
sph_d_ravel = self.sph_d.ravel()
range_d = sph_d_ravel < max_dist
idx_range = np.array(np.where(range_d == True)).ravel()
val_range = sph_d_ravel[idx_range]
idx_sort_val_range = np.argsort(val_range)
self.sort_d = idx_range[idx_sort_val_range]
def data_variogram(self, max_dist = 11000):
"""
Function for calculating variogram from data
"""
import numpy as np
self.find_sort_d(max_dist = max_dist)
cloud_all = np.zeros([self.N_grid, self.N_grid])
for i in range(0,self.N_grid):
#cloud = (self.data[i]-self.data)**2
cloud = 0.5*(self.data[i]-self.data)**2
cloud_all[i,:] = cloud
self.cloud_sorted = cloud_all.ravel()[self.sort_d]
self.sph_d_sorted = self.sph_d.ravel()[self.sort_d]
def data_semivariogram(self, max_cloud, n_lags):
"""
Function for calculating semivariogram from data by taking the mean of
equidistant lags
"""
import numpy as np
pics = np.zeros(n_lags-1)
lags = np.zeros(n_lags-1)
#pic_zero = 0.5*np.mean(self.cloud_sorted[:self.N_grid])
pic_zero = np.mean(self.cloud_sorted[:self.N_grid])
lag_zero = np.mean(self.sph_d_sorted[:self.N_grid])
pics[0] = pic_zero
lags[0] = lag_zero
lags_geom = np.linspace(self.N_grid+2, max_cloud, n_lags, dtype=int)
for n in np.arange(0,n_lags-2):
#pic = 0.5*np.mean(self.cloud_sorted[lags_geom[n]:lags_geom[n+1]:1])
pic = np.mean(self.cloud_sorted[lags_geom[n]:lags_geom[n+1]:1])
pics[n+1] = pic
lag_c = np.mean(self.sph_d_sorted[lags_geom[n]:lags_geom[n+1]:1])
lags[n+1] = lag_c
self.lags = lags
self.pics = pics
def semivariogram_model(self, h, a, C0, C1, C2 = None, C3 = None, sv_mode = 'spherical'):
import numpy as np
if sv_mode == 'spherical':
'''
Spherical model of the semivariogram
'''
hi = np.argsort(h)
hir = np.argsort(hi)
sv_model = np.zeros(len(h),dtype=np.longdouble)
hs = h[hi]
hla = hs[hs<a]
sv_model[0:len(hla)] = C0 + C1*( 1.5*hla/a - 0.5*(hla/a)**3 )
sv_model[len(hla):] = C0 + C1
sv_model = sv_model[hir]
elif sv_mode == 'dub_spherical':
'''
Spherical model of the semivariogram
'''
hi = np.argsort(h)
hir = np.argsort(hi)
sv_model = np.zeros(len(h),dtype=np.longdouble)
hs = h[hi]
hla = hs[hs<a]
ha2 = h>C3
sv_model[0:len(hla)] = C0 + C1*( 1.5*hla/a - 0.5*(hla/a)**3 ) + C2*( 1.5*hla/C3 - 0.5*(hla/C3)**3)
sv_model[len(hla):] = C0 + C1 + C2*( 1.5*hs[len(hla):]/C3 - 0.5*(hs[len(hla):]/C3)**3)
sv_model[ha2[hi]] = C0 + C1 + C2
sv_model = sv_model[hir]
elif sv_mode == 'gaussian':
'''
Gaussian model of the semivariogram
'''
sv_model = C0 + C1*(1-np.exp(-(3*np.ravel(h))**2/a**2))
elif sv_mode == 'exponential':
'''
Exponential model of the semivariogram
'''
import numpy as np
sv_model = C0 + C1*(1-np.exp(-3*h/a))
#sv_model = C0 + C1*(1-np.exp(-h/a))
#sv_model = C0 + C1*(np.exp(-h/a))
elif sv_mode == 'power':
'''
Power model of the semivariogram
'''
hi = np.argsort(h)
hir = np.argsort(hi)
sv_model = np.zeros(len(h),dtype=np.longdouble)
hs = h[hi]
hla = hs[hs<a]
sv_model[0:len(hla)] = C0 + C1*hla**a
sv_model[len(hla):] = C0 + C1*np.array(hs[len(hla):])**a
sv_model = sv_model[hir]
elif sv_mode == 'hole':
'''
Hole model of the semivariogram
'''
sv_model = C0 + C1*(1-np.cos(h/a*np.pi))
elif sv_mode == 'hole_damp':
'''
Hole model of the semivariogram
'''
sv_model = C0 + C1*(1-np.exp(-3*h/C2)*np.cos(h/a*np.pi))
elif sv_mode == 'nested_hole_gau':
'''
Hole model of the semivariogram
'''
hi = np.argsort(h)
hir = np.argsort(hi)
sv_model = np.zeros(len(h),dtype=np.longdouble)
hs = h[hi]
hla = hs[hs<a]
sv_model[0:len(hla)] = C0 + C1*(1-np.cos(hla/a*np.pi)) + C2*(1-np.exp(-(3*hla)**2/a**2))
sv_model[len(hla):] = C0 + C1*(1-np.cos(np.array(hs[len(hla):])/a*np.pi)) + C2*(1-np.exp(-(3*np.array(hs[len(hla):]))**2/a**2))
sv_model = sv_model[hir]
elif sv_mode == 'nested_sph_gau':
'''
Nested spherical and gaussian model of the semivariogram
'''
hi = np.argsort(h)
hir = np.argsort(hi)
sv_model = np.zeros(len(h),dtype=np.longdouble)
hs = h[hi]
hla = hs[hs<a]
sv_model[0:len(hla)] = C0 + C1*( 1.5*hla/a - 0.5*(hla/a)**3 ) + C2*(1-np.exp(-(3*hla)**2/a**2))
sv_model[len(hla):] = C0 + C1 + C2*(1-np.exp(-(3*np.array(hs[len(hla):]))**2/a**2))
sv_model = sv_model[hir]
elif sv_mode == 'nested_sph_exp':
'''
Nested spherical and exponential model of the semivariogram
'''
hi = np.argsort(h)
hir = np.argsort(hi)
sv_model = np.zeros(len(h),dtype=np.longdouble)
hs = h[hi]
hla = hs[hs<a]
sv_model[0:len(hla)] = C0 + C1*( 1.5*hla/a - 0.5*(hla/a)**3 ) + C2*(1-np.exp(-(3*hla)/a))
sv_model[len(hla):] = C0 + C1 + C2*(1-np.exp(-(3*np.array(hs[len(hla):]))/a))
sv_model = sv_model[hir]
elif sv_mode == 'nested_exp_gau':
'''
Nested exponential and gaussian model of the semivariogram
'''
hi = np.argsort(h)
hir = np.argsort(hi)
sv_model = np.zeros(len(h),dtype=np.longdouble)
hs = h[hi]
hla = hs[hs<a]
sv_model[0:len(hla)] = C0 + C1*(1-np.exp(-(3*hla)/a)) + C2*(1-np.exp(-(3*hla)**2/a**2))
sv_model[len(hla):] = C0 + C1*(1-np.exp(-(3*np.array(hs[len(hla):]))/a)) + C2*(1-np.exp(-(3*np.array(hs[len(hla):]))**2/a**2))
sv_model = sv_model[hir]
elif sv_mode == 'nested_sph_exp_gau':
'''
Nested spherical and exponential model of the semivariogram
'''
hi = np.argsort(h)
hir = np.argsort(hi)
sv_model = np.zeros(len(h),dtype=np.longdouble)
hs = h[hi]
hla = hs[hs<a]
sv_model[0:len(hla)] = C0 + C1*( 1.5*hla/a - 0.5*(hla/a)**3 ) + C2*(1-np.exp(-(3*hla)/a)) + C3*(1-np.exp(-(3*hla)**2/a**2))
sv_model[len(hla):] = C0 + C1 + C2*(1-np.exp(-(3*np.array(hs[len(hla):]))/a)) + C3*(1-np.exp(-(3*np.array(hs[len(hla):]))**2/a**2))
sv_model = sv_model[hir]
else:
print('Unknown model type')
return
return sv_model
def varioLUT(self, a, C0, C1, C2 = None, C3 = None, sv_model = 'spherical'):
import numpy as np
#from SDSSIM_utility import printProgressBar
'''
semi-variogram LUT generation
'''
#vario_lut = np.longdouble(np.zeros([self.N_grid, self.N_grid]))
vario_lut = np.double(np.zeros([self.N_grid, self.N_grid]))
for i in range(0,self.N_grid):
vario_lut[:,i] = self.semivariogram_model(self.sph_d[i,:], a, C0, C1, C2=C2, C3=C3, sv_mode=sv_model)
return vario_lut
def semivar(self, model_lags = 'all', model = 'nested_sph_exp_gau', max_dist = 11000, lag_length = 5,
nolut = False, bounds = True, zero_nugget = False, set_model = False, hit_target_var = False):
from math import inf
import numpy as np
from scipy.optimize import curve_fit
#from sklearn.preprocessing import normalize
self.sv_model_lags = model_lags
self.sv_max_dist = max_dist
self.sv_lag_length = lag_length
self.sv_zero_nugget = zero_nugget
self.data_variogram(max_dist=max_dist)
self.max_cloud = len(self.sort_d)
d_max = np.max(self.sph_d_sorted)
self.n_lags = int(d_max/lag_length) # lags from approx typical distance between core grid points
print("____semi-variogram setup___")
print("")
print("Number of data used: %d" %self.max_cloud)
print("Max data distance: %.3f km" %d_max)
print("Lag length chosen: %.1f km" %lag_length)
print("Number of lags: %d" %self.n_lags)
print("Number of modelling lags:",model_lags)
print("")
self.data_semivariogram(self.max_cloud, self.n_lags)
#print('Generating semi-variogram model')
#print("")
if model_lags == 'all':
lags_model = self.lags
pics_model = self.pics
else:
lags_model = self.lags[:model_lags]
pics_model = self.pics[:model_lags]
# Set model name for plotting and logicals for model selection
self.model_names = {'spherical':'spherical', 'dub_spherical':'double spherical', 'gaussian':'gaussian', 'exponential':'exponential', 'power':'power', 'hole':'hole', 'hole_damp':'dampened hole', 'nested_hole_gau':'hole+Gaussian', 'nested_sph_gau':'spherical+Gaussian', 'nested_sph_exp':'spherical+exponential', 'nested_exp_gau':'exponential+Gaussian', 'nested_sph_exp_gau':'spherical+exponential+Gaussian'}
self.model_select_simple = np.logical_or.reduce((model=='nested_sph_gau', model=='nested_sph_exp', model=='nested_exp_gau', model=='nested_hole_gau', model=='hole_damp'))
self.model_select_advanced = np.logical_or.reduce((model == 'nested_sph_exp_gau', model == 'dub_spherical'))
"""SET MODEL OR NOT"""
if set_model == False:
if model == 'spherical':
if zero_nugget == False:
def semivar_return(lags_model, a, C0, C1):
return C0 + C1*(1.5*lags_model/a-0.5*(lags_model/a)**3)
elif hit_target_var == True:
def semivar_return(lags_model, a):
return (1.5*lags_model/a-0.5*(lags_model/a)**3)
else:
def semivar_return(lags_model, a, C1):
return C1*(1.5*lags_model/a-0.5*(lags_model/a)**3)
elif model == 'dub_spherical':
if zero_nugget == False:
def semivar_return(lags_model, a, C0, C1, C2, C3):
return C0 + C1*(1.5*lags_model/a-0.5*(lags_model/a)**3) + C2*(1.5*lags_model/C3-0.5*(lags_model/C3)**3)
else:
def semivar_return(lags_model, a, C1, C2, C3):
return C1*(1.5*lags_model/a-0.5*(lags_model/a)**3) + C2*(1.5*lags_model/C3-0.5*(lags_model/C3)**3)
elif model == 'gaussian':
if zero_nugget == False:
def semivar_return(lags_model, a, C0, C1):
return C0 + C1*(1-np.exp(-(3*lags_model)**2/a**2))
else:
def semivar_return(lags_model, a, C1):
return C1*(1-np.exp(-(3*lags_model)**2/a**2))
elif model == 'exponential':
if zero_nugget == False:
def semivar_return(lags_model, a, C0, C1):
return C0 + C1*(1-np.exp(-3*lags_model/a))
#return C0 + C1*(1-np.exp(-lags_model/a))
#return C0 + C1*(np.exp(-lags_model/a))
elif hit_target_var == True:
def semivar_return(lags_model, a):
return (1-np.exp(-3*lags_model/a))
else:
def semivar_return(lags_model, a, C1):
return C1*(1-np.exp(-3*lags_model/a))
elif model == 'power':
if zero_nugget == False:
def semivar_return(lags_model, a, C0, C1):
return C0 + C1*lags_model**a
else:
def semivar_return(lags_model, a, C1):
return C1*lags_model**a
elif model == 'hole':
def semivar_return(lags_model, a, C0, C1):
return C0 + C1*(1-np.cos(lags_model/a*np.pi))
elif model == 'hole_damp':
def semivar_return(lags_model, a, C0, C1, C2):
return C0 + C1*(1-np.exp(-3*lags_model/C2)*np.cos(lags_model/a*np.pi))
elif model == 'nested_hole_gau':
def semivar_return(lags_model, a, C0, C1, C2):
return C0 + C1*(1-np.cos(lags_model/a*np.pi)) + C2*(1-np.exp(-(3*lags_model)**2/a**2))
elif model == 'nested_sph_gau':
def semivar_return(lags_model, a, C0, C1, C2):
return C0 + C1*(1.5*lags_model/a-0.5*(lags_model/a)**3) + C2*(1-np.exp(-(3*lags_model)**2/a**2))
elif model == 'nested_sph_exp':
def semivar_return(lags_model, a, C0, C1, C2):
return C0 + C1*(1.5*lags_model/a-0.5*(lags_model/a)**3) + C2*(1-np.exp(-(3*lags_model)/a))
elif model == 'nested_exp_gau':
if zero_nugget == False:
def semivar_return(lags_model, a, C0, C1, C2):
return C0 + C1*(1-np.exp(-(3*lags_model)/a)) + C2*(1-np.exp(-(3*lags_model)**2/a**2))
else:
def semivar_return(lags_model, a, C1, C2):
return C1*(1-np.exp(-(3*lags_model)/a)) + C2*(1-np.exp(-(3*lags_model)**2/a**2))
elif model == 'nested_sph_exp_gau':
if zero_nugget == False:
def semivar_return(lags_model, a, C0, C1, C2, C3):
return C0 + C1*(1.5*lags_model/a-0.5*(lags_model/a)**3) + C2*(1-np.exp(-(3*lags_model)/a)) + C3*(1-np.exp(-(3*lags_model)**2/a**2))
else:
def semivar_return(lags_model, a, C1, C2, C3): # FOR ZERO NUGGET
return C1*(1.5*lags_model/a-0.5*(lags_model/a)**3) + C2*(1-np.exp(-(3*lags_model)/a)) + C3*(1-np.exp(-(3*lags_model)**2/a**2)) # FOR ZERO NUGGET
else:
print('wrong model type chosen')
if bounds == True:
"""Bounds and start values for curve fit"""
if model == 'power':
if zero_nugget == False:
p0 = [2.0,np.min(pics_model),np.max(pics_model)]
bounds = (0, [2.0, inf, inf])
else:
p0 = [2.0,np.max(pics_model)]
bounds = (0, [2.0, inf])
elif np.logical_or(model=='nested_sph_gau',model=='nested_sph_exp'):
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.min(pics_model),np.max(pics_model),np.max(pics_model)]
bounds = (0, [lags_model[-1], inf, np.max(pics_model), np.max(pics_model)])
elif model=='nested_exp_gau':
if zero_nugget == False:
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.min(pics_model),np.max(pics_model),np.max(pics_model)]
bounds = (0, [lags_model[-1], inf, np.max(pics_model), np.max(pics_model)])
else:
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.max(pics_model),np.max(pics_model)]
bounds = (0, [lags_model[-1], np.max(pics_model), np.max(pics_model)])
elif model=='nested_hole_gau':
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.min(pics_model),np.max(pics_model),np.max(pics_model)]
bounds = (0, [lags_model[-1], inf, np.max(pics_model), np.max(pics_model)])
elif model=='hole_damp':
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.min(pics_model),np.max(pics_model),5*np.max(lags_model)]
bounds = (0, [lags_model[-1], inf, np.max(pics_model), 10*np.max(lags_model)])
elif model == 'nested_sph_exp_gau':
if zero_nugget == False:
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.min(pics_model),np.max(pics_model),np.max(pics_model),np.max(pics_model)]
bounds = (0, [lags_model[-1], inf, np.max(pics_model), np.max(pics_model),np.max(pics_model)])
else:
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.min(pics_model),np.max(pics_model),np.max(pics_model)]
bounds = (0, [lags_model[-1], np.max(pics_model), np.max(pics_model),np.max(pics_model)])
elif model == 'dub_spherical':
if zero_nugget == False:
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.min(pics_model),np.max(pics_model),np.max(pics_model),np.mean(lags_model[-int(len(lags_model)/2.0)])]
bounds = (0, [lags_model[-1], inf, np.max(pics_model), np.max(pics_model),lags_model[-1]])
else:
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.min(pics_model),np.max(pics_model),np.mean(lags_model[-int(len(lags_model)/2.0)])]
bounds = (0, [lags_model[-1], np.max(pics_model), np.max(pics_model),lags_model[-1]])
else:
if zero_nugget == False:
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.min(pics_model),np.max(pics_model)]
bounds = (0, [lags_model[-1], inf, np.max(pics_model)])
elif hit_target_var == True:
p0 = [np.max(pics_model)]
bounds = (0, [np.max(pics_model)])
else:
p0 = [np.mean(lags_model[-int(len(lags_model)/4.0)]),np.max(pics_model)]
bounds = (0, [lags_model[-1], np.max(pics_model)])
if hit_target_var == True:
pics_model_in = pics_model/self.target_var
popt, pcov = curve_fit(semivar_return, lags_model, pics_model_in, bounds=bounds, p0 = p0)
else:
popt, pcov = curve_fit(semivar_return, lags_model, pics_model, bounds=bounds, p0 = p0)
else:
popt, pcov = curve_fit(semivar_return, lags_model, pics_model, method='lm')
self.lags_model = lags_model
self.pics_model = pics_model
"""Calculate or define nugget"""
if zero_nugget == False:
C0 = popt[1]
C1 = popt[2]
C2 = None
C3 = None
if self.model_select_simple:
C2 = popt[3]
elif self.model_select_advanced:
C2 = popt[3]
C3 = popt[4]
elif hit_target_var == True:
C0 = 0.0 # FOR ZERO NUGGET
C1 = self.target_var
C2 = None
C3 = None
else:
C0 = 0.0 # FOR ZERO NUGGET
C1 = popt[1] # FOR ZERO NUGGET
C2 = None
C3 = None
if self.model_select_simple:
C2 = popt[2]
elif self.model_select_advanced:
C2 = popt[2] # FOR ZERO NUGGET
C3 = popt[3] # FOR ZERO NUGGET
"""Calculate or define correlation length"""
a = popt[0]
else:
a = set_model["a"]
C0 = set_model["C0"]
C1 = set_model["C1"]
C2 = set_model["C2"]
C3 = set_model["C3"]
"""Spherical model prediction"""
#lags_sv_curve = np.arange(0,int(np.round(lags[-1]))) # Very weird bug when using this for Gaussian model at lengths > 15K
self.lags_sv_curve = np.linspace(0, int(np.round(self.lags[-1])), len(self.lags))
if self.model_select_simple:
self.sv_curve = self.semivariogram_model(self.lags_sv_curve, a, C0, C1, C2 = C2, sv_mode = model)
elif self.model_select_advanced:
self.sv_curve = self.semivariogram_model(self.lags_sv_curve, a, C0, C1, C2 = C2, C3 = C3, sv_mode = model)
else:
self.sv_curve = self.semivariogram_model(self.lags_sv_curve, a, C0, C1, sv_mode = model)
print('Semi-variogram model determined, starting LUT computation')
print("")
if nolut == False:
if self.model_select_simple:
self.sv_lut = self.varioLUT(a, C0, C1, C2 = C2, sv_model = model)
elif self.model_select_advanced:
self.sv_lut = self.varioLUT(a, C0, C1, C2 = C2, C3 = C3, sv_model = model)
else:
self.sv_lut = self.varioLUT(a, C0, C1, sv_model = model)
# Set model in class
self.model = model
self.a_sv = a
self.C0 = C0
self.C1 = C1
self.C2 = C2
self.C3 = C3
def cov_model(self, r_at = None, N_cut = 200):
if r_at == None:
r_at = self.a
#tap_to = tap_to + 1 # One extra for overlap between R_add and R
#n_tap = self.N_SH + tap_to - 1 # And one less in the sum as a result
# g ensemble and parameters
if self.sim_type == "core_ens":
g_ens = np.genfromtxt("mikkel_tools/models_shc/gnm_midpath.dat").T*10**9
elif self.sim_type == "lith_ens":
#g_ens = np.load("mikkel_tools/models_shc/lithosphere_g_in_rotated.npy")
g_ens = np.load("mikkel_tools/models_shc/LiP_ensemble_N500_n120_p05_vary_crust.npy")
g_ens = g_ens[:mt_util.shc_vec_len(self.N_SH),:]
if self.sim_type == "core_ens":
g_cut = g_ens[:self.N_SH*(2+self.N_SH),N_cut:] # Truncate g
elif self.sim_type == "lith_ens":
#g_cut = g_ens[:self.N_SH*(2+self.N_SH),::self.lith_ens_cut]
g_cut = g_ens[:self.N_SH*(2+self.N_SH),:]
R = mt_util.lowe_shspec(self.N_SH, r_at, self.a, g_cut)
R = R[:,np.mean(R,axis=0)>5]
# Angular distance matrix
c_angdist = np.cos(mt_util.haversine(1, self.grid_phi.reshape(1,-1), 90-self.grid_theta.reshape(1,-1),
self.grid_phi.reshape(-1,1), 90-self.grid_theta.reshape(-1,1)))
c_unique, c_return = np.unique(np.ravel(c_angdist), return_inverse = True)
# Compute constants based on Chris' note eqn. 11
C_const = (np.arange(1,self.N_SH+1)+1)/(2*np.arange(1,self.N_SH+1)+1)
# Constant and R
CR = C_const.reshape(-1,1)*R
# Generate matrix of all required Schmidt semi-normalized legendre polynomials
Pn = []
for cmu in c_unique:
Pn.append(pyshtools.legendre.PlSchmidt(self.N_SH,cmu)[1:].reshape(-1,))
Pn = np.array(Pn)[:,:]
#Pn = np.array(Pn).reshape((c_angdist.shape[0],c_angdist.shape[1],-1))
# Determine covariance model according to eqn. 11
C_Br_model = np.mean(Pn@CR,axis=1)[c_return].reshape((c_angdist.shape[0],c_angdist.shape[1]))
#if c_angdist.shape[0] <= 2000:
# C_Br = Pn@CR
# C_Br_model = np.mean(C_Br,axis=2)
#else:
# C_Br = np.zeros((self.grid_N, self.grid_N, 1))
# for i in np.arange(0,R.shape[1]):
# C_Br += Pn@CR[:,[i]]
# C_Br_model = C_Br[:,:,0]/R.shape[1]
# Positive definite covariance?
core_eigval = spl.eigh(C_Br_model, eigvals_only=True)
N_neg_eigval = len(core_eigval[core_eigval<=0])
print("All eigenvalues > 0:", np.all(core_eigval>=0))
print("Cov model is pos def:", mt_util.is_pos_def(C_Br_model))
if np.all(core_eigval>=0) == False:
print("Number of negative eigenvalues:",N_neg_eigval,"/",len(core_eigval))
# Save covariance model variable
self.C_ens = C_Br_model
def cov_model_taper(self, r_at = None, tap_to = 500, tap_exp_p1 = 5, tap_exp_p2 = 2,
tap_scale_start = 0, tap_scale_end = 24, plot_taper = False,
save_fig = False, save_string = "", save_dpi = 300, N_cut = 200):
if r_at == None:
r_at = self.a
tap_to = tap_to + 1 # One extra for overlap between R_add and R
n_tap = self.N_SH + tap_to - 1 # And one less in the sum as a result
# g ensemble and parameters
if self.sim_type == "core_ens":
g_ens = np.genfromtxt("mikkel_tools/models_shc/gnm_midpath.dat").T*10**9
elif self.sim_type == "core_alt":
import hdf5storage
g_ens = -(hdf5storage.loadmat("mikkel_tools/models_shc/Gauss_Bsurf_2021.mat")["gnm"].T)[:,:].copy()
elif self.sim_type == "lith_ens":
#g_ens = np.load("mikkel_tools/models_shc/lithosphere_g_in_rotated.npy")
g_ens = np.load("mikkel_tools/models_shc/LiP_ensemble_N500_n120_p05_vary_crust.npy")
g_ens = g_ens[:mt_util.shc_vec_len(self.N_SH),:]
if self.sim_type == "core_ens":
g_cut = g_ens[:self.N_SH*(2+self.N_SH),N_cut:] # Truncate g
elif self.sim_type == "core_alt":
g_cut = g_ens[:self.N_SH*(2+self.N_SH),N_cut:] # Truncate g
elif self.sim_type == "lith_ens":
#g_cut = g_ens[:self.N_SH*(2+self.N_SH),::self.lith_ens_cut]
g_cut = g_ens[:self.N_SH*(2+self.N_SH),:]
R = mt_util.lowe_shspec(self.N_SH, r_at, self.a, g_cut)
R = R[:,np.mean(R,axis=0)>5]
# Angular distance matrix
c_angdist = np.cos(mt_util.haversine(1, self.grid_phi.reshape(1,-1), 90-self.grid_theta.reshape(1,-1),
self.grid_phi.reshape(-1,1), 90-self.grid_theta.reshape(-1,1)))
c_unique, c_return = np.unique(np.ravel(c_angdist), return_inverse = True)
# Compute covariances based on Chris' note eqn. 11
C_const = (np.arange(1,n_tap+1)+1)/(2*np.arange(1,n_tap+1)+1)
# Generate matrix of all required Schmidt semi-normalized legendre polynomials
Pn = []
for cmu in c_unique:
Pn.append(pyshtools.legendre.PlSchmidt(n_tap,cmu)[1:].reshape(-1,))
Pn = np.array(Pn)[:,:]
#Pn = np.array(Pn).reshape((c_angdist.shape[0],c_angdist.shape[1],-1))
# Define taper with inverse powered exponential sum
lin_exp = np.linspace(tap_scale_start, tap_scale_end, tap_to)
tap_exp = (0.5*np.exp(-tap_exp_p1*lin_exp) + 0.5*np.exp(-tap_exp_p2*lin_exp)).reshape(-1,1)
# Take taper as factor on last spectra values and add to true prior spectra
R_add = R[-1,:]*tap_exp
R_tap = np.vstack((R,R_add[1:,:]))
# Constant and R
CR = C_const.reshape(-1,1)*R_tap
# Determine covariance model according to eqn. 11
C_Br_model = np.mean(Pn@CR,axis=1)[c_return].reshape((c_angdist.shape[0],c_angdist.shape[1]))
#if c_angdist.shape[0] <= 2000:
# C_Br = Pn@CR
# C_Br_model = np.mean(C_Br,axis=2)
#else:
# C_Br = np.zeros((self.grid_N, self.grid_N, 1))
# for i in np.arange(0,R.shape[1]):
# C_Br += Pn@CR[:,[i]]
# C_Br_model = C_Br[:,:,0]/R.shape[1]
# Positive definite covariance?
core_eigval = spl.eigh(C_Br_model, eigvals_only=True)
N_neg_eigval = len(core_eigval[core_eigval<=0])
print("All eigenvalues > 0:", np.all(core_eigval>=0))
print("Cov model is pos def:", mt_util.is_pos_def(C_Br_model))
if np.all(core_eigval>=0) == False:
print("Number of negative eigenvalues:",N_neg_eigval,"/",len(core_eigval))
# Save covariance model variable
self.C_ens_tap = C_Br_model
# Generate plot to show taper
if plot_taper == True:
lin_exp = np.linspace(tap_scale_start,tap_scale_end,10000)
lin_deg = np.linspace(1,tap_to,10000)
tap_exp = (0.5*np.exp(-tap_exp_p1*lin_exp) + 0.5*np.exp(-tap_exp_p2*lin_exp)).reshape(-1,1)
R_show = R[-1,:]*tap_exp
# Spectra
fig, axes = plt.subplots(1, 2, figsize=(10,4))
for i in np.arange(R_tap.shape[1]):
if i == 0:
axes[0].plot(np.arange(1,n_tap+1),R_tap[:,i],color=(0.6,0.6,0.6),label="Tapered ensemble")
axes[0].plot(lin_deg+self.N_SH-1,R_show[:,self.ens_idx],zorder = 10, label ="Taper function for highlight")
axes[0].plot(np.arange(1,n_tap+1)[:self.N_SH],R_tap[:self.N_SH,self.ens_idx],"o",zorder = 11, label = "Ensemble highlight truth")
axes[0].plot(np.arange(1,n_tap+1)[self.N_SH:],R_tap[self.N_SH:,self.ens_idx],"o",zorder = 11, label = "Ensemble highlight taper")
axes[1].plot(np.arange(1,n_tap+1),R_tap[:,i],color=(0.6,0.6,0.6),label="Tapered ensemble")
axes[1].plot(lin_deg+self.N_SH-1,R_show[:,self.ens_idx],zorder = 10, label ="Taper function for highlight")
axes[1].plot(np.arange(1,n_tap+1)[:self.N_SH],R_tap[:self.N_SH,self.ens_idx],"o",zorder = 11, label = "Ensemble highlight truth")
axes[1].plot(np.arange(1,n_tap+1)[self.N_SH:],R_tap[self.N_SH:,self.ens_idx],"o",zorder = 11, label = "Ensemble highlight taper")
else:
axes[0].plot(np.arange(1,n_tap+1),R_tap[:,i],color=(0.6,0.6,0.6))
axes[1].plot(np.arange(1,n_tap+1),R_tap[:,i],color=(0.6,0.6,0.6))
axes[0].set_xlim(self.N_SH-5,self.N_SH+10)
#axes[0].set_ylim(0,1.5*10**10)
axes[0].set_ylim(0,1.2*np.max(R_tap[self.N_SH,:]))
axes[1].set_xlim(0,tap_to/2)
#axes[1].set_ylim(0, 10**10)
axes[1].set_ylim(0, np.max(R_tap[self.N_SH,:]))
axes[0].legend(fontsize="small")
axes[1].legend(fontsize="small")
axes[0].set_ylabel("Power [$nT^2$]")
axes[0].set_xlabel("SH degree, n")
axes[1].set_ylabel("Power [$nT^2$]")
axes[1].set_xlabel("SH degree, n")
fig.suptitle('Taper function: $f_t = 0.5e^{{-{}n}} + 0.5e^{{-{}n}}$'.format(tap_exp_p1, tap_exp_p2), fontsize=10)
if save_fig == True:
fig.savefig('cov_taper_{}.pdf'.format(save_string), bbox_inches='tight', dpi = save_dpi)
plt.show()
def sv_m_DSS(self,N,N_sim,m_DSS,sort_d,n_lags,max_cloud):
"""
NEW Function for calculating semivariogram from simulations by taking the mean of
equidistant lags
"""
pics_m_DSS = np.zeros([n_lags-1,N_sim])
for j in np.arange(0,N_sim):
cloud_all = np.zeros([N,N])
for i in np.arange(0,N):
cloud = 0.5*(m_DSS[i,j]-m_DSS[:,j])**2
cloud_all[i,:] = cloud
pics_c = np.zeros(n_lags-1)
cloud_ravel = np.ravel(cloud_all)[sort_d]
pic_zero = np.mean(cloud_ravel[:N])
#pic_zero = 0.5*np.mean(cloud_ravel[:N])
pics_c[0] = pic_zero
lags_geom = np.linspace(N+2,max_cloud,n_lags,dtype=int)
for n in np.arange(0,n_lags-2):
#pic = 0.5*np.mean(cloud_ravel[lags_geom[n]:lags_geom[n+1]:1])
pic = np.mean(cloud_ravel[lags_geom[n]:lags_geom[n+1]:1])
pics_c[n+1] = pic
pics_m_DSS[:,j] = pics_c
self.pics_m_DSS = pics_m_DSS
def integrating_kernel(self, obs_obj, C_e_const = 2, print_ti_est_res = False, C_mm_supply = None):
G_mcal = mt_util.Gr_vec(self.r_grid, obs_obj.r_grid, self.lat, obs_obj.lat, self.lon, obs_obj.lon)
self.G = np.pi/(self.grid_nmax+0.5)*np.multiply(self.grid_w,G_mcal) # +0.5 for parity with SHTOOLS
C_e = np.diag(C_e_const**2*np.ones(obs_obj.grid_N,)) # No need to store C_e outside of here
if C_mm_supply is None:
self.C_mm_all = self.target_var-self.sv_lut
else:
self.C_mm_all = C_mm_supply
C_dm_all = self.G*self.C_mm_all
self.C_dd = C_dm_all*self.G.T + C_e
self.C_dm_all = C_dm_all.T
self.C_e_const = C_e_const
if print_ti_est_res == True:
# Compute forward and get residuals to synthetic observations
fwd_leg = self.G*self.data.reshape(-1,1)
fwd_leg_res = obs_obj.data - fwd_leg.reshape(-1,)
# RMSE
rmse_leg = np.sqrt(np.mean(np.power(fwd_leg_res,2)))
print("")
print("Gauss-Legendre RMSE:\t %0.12f" %rmse_leg)
plt.figure()
y,binEdges=np.histogram(fwd_leg_res,bins=200)
bincenters = 0.5*(binEdges[1:]+binEdges[:-1])
plt.plot(bincenters,y,'C0',label="Gauss-Legendre")
plt.xlabel("Radial field residuals [nT]")
plt.ylabel("Count")
plt.legend()
plt.show()
def covmod_lsq_equiv(self, obs, C_mm, G, r_at, geomag_scale = True):
obs = obs.reshape(-1,1)
C_e = np.zeros((len(obs),len(obs)))
C_e[np.arange(1,len(obs)),np.arange(1,len(obs))] = self.C_e_const**2
S = C_e + [email protected][email protected]
T = np.linalg.inv(S)
self.m_equiv_lsq = [email protected]@T@obs
self.lsq_equiv_pred = [email protected]_equiv_lsq
self.lsq_equiv_res = obs - self.lsq_equiv_pred
self.g_equiv_lsq, _ = mt_util.sh_expand_glq(self.m_equiv_lsq, self.grid_nmax, self.grid_w_shtools, self.grid_zero, self.N_SH, geomag_scale = geomag_scale, geomag_r_at = r_at)
#C_cilm = pyshtools.expand.SHExpandGLQ(self.m_equiv_lsq.reshape(self.grid_nmax+1,2*self.grid_nmax+1), self.grid_w_shtools, self.grid_zero, [2, 1, self.grid_nmax])
#C_index = np.transpose(pyshtools.shio.SHCilmToCindex(C_cilm))
#if geomag_scale == True:
# nm_C = mt_util.array_nm(self.grid_nmax)
# C_corr_sh = 1/(nm_C[:,[0]]+1)*1/(self.a/r_at)**(nm_C[:,[0]]+2)
# C_index = C_index[1:,:]*C_corr_sh
#else:
# C_index = C_index[1:,:]
#C_vec = mt_util.gauss_vector(C_index, self.grid_nmax, i_n = 0, i_m = 1)
#self.g_lsq_equiv = C_vec
def covmod_lsq_equiv_sep(self, obs, semivar_c, semivar_l, target_var_c, target_var_l, G_d_sep,
title="", errorvar = 3**2):
d_0 = obs
G = G_d_sep.copy()
C_M_c = target_var_c - semivar_c
C_M_l = target_var_l - semivar_l
C_M = np.zeros((G.shape[1],G.shape[1]))
C_M[:C_M_c.shape[0],:C_M_c.shape[0]] = C_M_c
C_M[-C_M_l.shape[0]:,-C_M_l.shape[0]:] = C_M_l
C_D = np.zeros((len(d_0),len(d_0)))
C_D[np.arange(1,len(d_0)),np.arange(1,len(d_0))] = errorvar
S = C_D + G*C_M*G.T
T = np.linalg.inv(S)
m_equiv_lsq = C_M*G.T*T*d_0
lsq_equiv_pred = G_d_sep*m_equiv_lsq
lsq_equiv_res = obs - lsq_equiv_pred
return m_equiv_lsq, lsq_equiv_pred, lsq_equiv_res
def conditional_lookup(self, mu_k, sigma_sq_k, dm, dv, unit_d = False, scaling = True, return_idx = False):
from scipy.stats import norm
#conditional_lookup(self, cond_mean, cond_var, cond_dist, cond_dist_size, mu_k, sigma_sq_k, dm, dv):
#conditional_lookup(core.CQF_mean, core.CQF_var, core.CQF_dist, core.condtab_normsize, mu_k, sigma_sq_k, dm_c, dv_c)
#dist = np.power((condtab["CQF mean"]-mu_k)/dm,2)+np.power((condtab["CQF var"]-sigma_sq_k)/dv,2)
if unit_d == True:
distance = np.power((self.CQF_mean-mu_k),2)+abs(self.CQF_var-sigma_sq_k)
else:
#distance = np.power((self.CQF_mean-mu_k)/dm,2)+abs(self.CQF_var-sigma_sq_k)/np.sqrt(dv)
distance = abs(self.CQF_mean-mu_k)/dm+abs(self.CQF_var-sigma_sq_k)/dv
nearest = np.unravel_index(np.argmin(distance),self.CQF_mean.shape)
idx_n = nearest[0]
idx_v = nearest[-1]
#if idx_v > 50:
# print(idx_v)
m_i = self.CQF_dist[idx_n,idx_v,np.random.randint(0,self.condtab_normsize,size=1)]
if scaling == True:
m_i_mean = self.CQF_mean[idx_n,idx_v]
m_i_std = np.sqrt(self.CQF_var[idx_n,idx_v],dtype=np.float64)
m_k = (m_i - m_i_mean)*np.sqrt(sigma_sq_k)/m_i_std+mu_k
else:
m_k = m_i
if return_idx == True:
return m_k, (idx_n, idx_v)
else:
return m_k
def run_sim(self, N_sim, N_m, C_mm_all, C_dd, C_dm_all, G, observations, training_image,
observations_direct = None, observations_direct_loc = None, observations_direct_e = None, use_sgs = False,
collect_all = False, scale_m_i = True, unit_d = False, sense_running_error = False, notebook_style = True, save_string = "test",
solve_cho = True, sim_stochastic = False, separation = False, separation_lim = None, separation_obj_1 = None,
separation_obj_2 = None):
import time
import random
import scipy as sp
"""
Input
N_sim:
N_m:
prior_data:
Output
"""
max_cov = np.max(C_mm_all)
#if observations_direct_e is not None:
# C_mm_all[np.arange(self.grid_N),np.arange(self.grid_N)] += observations_direct_e
"""Number of simulations"""
self.N_sim = N_sim
m_DSS = np.zeros((N_m, N_sim))
time_average = np.zeros((N_sim))
"""save variables"""
self.idx_nv_collect = list()
lagrange = list()
self.kriging_mv_collect = list()
rand_paths = list()
invshapes = list()
kriging_weights = list()
kriging_weights_rel_dat = list()
v_cond_vars = list()
lstsq_param = list()
C_dd_in = C_dd
""" Run sequential simulations"""
for realization in range(0,N_sim):
# Start timing
t0 = time.time()
random.seed(a=None)
np.random.seed()
# Initialize sequential simulation with random start
step_rnd_path = np.arange(N_m)
if observations_direct is not None:
step_rnd_path = np.delete(step_rnd_path, observations_direct_loc)
# Randomize index array to create random path
random.shuffle(step_rnd_path)
"""Run spherical direct sequential simulation"""
idx_v = np.empty([0,],dtype=int)
idx_n = np.empty([0,],dtype=int)
data_min = np.min(training_image)
data_max = np.max(training_image)
dm = data_max - data_min
dv = self.target_var
stepped_previously = np.empty([0,],dtype=int)
err_mag_sum = 0.0
len_stepped = 0
# Start random walk
for step in step_rnd_path:
C_mm_var = C_mm_all[step,step]
C_mm = np.empty([0,],dtype=np.longdouble)
C_dm = np.empty([0,],dtype=np.longdouble)
C_vm = np.empty([0,],dtype=np.longdouble)
c_mm = np.empty([0,1],dtype=np.longdouble)
c_dm = np.empty([0,1],dtype=np.longdouble)
c_vm = np.empty([0,1],dtype=np.longdouble)
mu_k = np.empty([0,],dtype=np.longdouble)
sigma_sq_k = np.empty([0,],dtype=np.longdouble)
idx_n = np.empty([0,],dtype=int)
idx_v = np.empty([0,],dtype=int)
m_i = np.empty([0,],dtype=np.longdouble)
m_k = None
err_mag_avg = np.empty([0,],dtype=np.longdouble)
kriging_weights = np.empty([0,],dtype=np.longdouble)
v_cond_var = np.empty([0,],dtype=np.longdouble)
#""" SORT METHOD """
#cov_walked = C_mm_all[step,stepped_previously]
if separation == True:
if step <= separation_lim:
sep_idx = 0
C_dd_in = C_dd[sep_idx]
else:
sep_idx = 1
C_dd_in = C_dd[sep_idx]
"""COV SETUP"""
# Set up m to m
c_mm = C_mm_all[step,stepped_previously].reshape(-1,1)
# Lookup all closest location semi-variances to each other (efficiently)
C_mm = (np.ravel(C_mm_all)[(stepped_previously + (stepped_previously * C_mm_all.shape[1]).reshape((-1,1))).ravel()]).reshape(stepped_previously.size, stepped_previously.size)
# Set up d to m, direct observations etc.
if observations_direct is not None:
if len_stepped == 0:
for step_direct in observations_direct_loc:
stepped_previously = np.append(stepped_previously, step_direct)
len_stepped += 1
m_DSS[stepped_previously,realization] = observations_direct
# Set up m to m
c_mm = C_mm_all[step,stepped_previously].reshape(-1,1)
# Lookup all closest location semi-variances to each other (efficiently)
C_mm = (np.ravel(C_mm_all)[(stepped_previously + (stepped_previously * C_mm_all.shape[1]).reshape((-1,1))).ravel()]).reshape(stepped_previously.size, stepped_previously.size)
if observations is not None:
c_dm = C_dm_all[step,:].reshape(-1,1)
C_dm = C_dm_all[stepped_previously,:]
c_vm = np.vstack((c_mm,c_dm))
C_vm = np.zeros((len(C_dd_in)+len(C_mm),len(C_dd_in)+len(C_mm)))
C_vm[-len(C_dd_in):,-len(C_dd_in):] = C_dd_in
C_vm[:len(C_mm),:len(C_mm)] = C_mm
C_vm[:len(C_mm),-len(C_dd_in):] = C_dm
C_vm[-len(C_dd_in):,:len(C_mm)] = C_dm.T
v_cond_var = m_DSS[stepped_previously,realization].reshape(-1,1)
v_cond_var = np.vstack((v_cond_var,observations.reshape(-1,1)))
else:
v_cond_var = m_DSS[stepped_previously,realization].reshape(-1,1)
c_vm = c_mm
C_vm = C_mm
elif sim_stochastic == False:
c_dm = C_dm_all[step,:].reshape(-1,1)
if len(stepped_previously) >= 1:
C_dm = C_dm_all[stepped_previously,:]
c_vm = np.vstack((c_mm,c_dm))
C_vm = np.zeros((len(C_dd_in)+len(C_mm),len(C_dd_in)+len(C_mm)))
C_vm[-len(C_dd_in):,-len(C_dd_in):] = C_dd_in
if len(stepped_previously) >= 1:
C_vm[:len(C_mm),:len(C_mm)] = C_mm
C_vm[:len(C_mm),-len(C_dd_in):] = C_dm
C_vm[-len(C_dd_in):,:len(C_mm)] = C_dm.T
v_cond_var = m_DSS[stepped_previously,realization].reshape(-1,1)
if len_stepped > 0:
v_cond_var = np.vstack((v_cond_var,observations.reshape(-1,1)))
else:
v_cond_var = observations.reshape(-1,1)
else:
if len_stepped > 1:
v_cond_var = m_DSS[stepped_previously,realization].reshape(-1,1)
c_vm = c_mm
C_vm = C_mm
else:
m_k = self.target_mean
if m_k == None:
"""SIMPLE KRIGING (SK)"""
#self.C_vm = C_vm
if solve_cho == True:
cho_lower = sp.linalg.cho_factor(C_vm)
kriging_weights = sp.linalg.cho_solve(cho_lower,c_vm)
else:
kriging_weights = np.linalg.solve(C_vm,c_vm)
#kriging_weights[kriging_weights<0.01] = 0.0
#sigma_sq_k = self.target_var - np.float(kriging_weights.reshape(1,-1)@c_vm)
sigma_sq_k = C_mm_var - np.float(kriging_weights.reshape(1,-1)@c_vm)
#sigma_sq_k = max_cov - np.float(kriging_weights.reshape(1,-1)@c_vm)
if sigma_sq_k < 0.0:
print("")
print("Negative kriging variance: %s" %sigma_sq_k)
print("")
kriging_weights[kriging_weights<0] = 0
#sigma_sq_k = self.target_var - np.float(kriging_weights.reshape(1,-1)@c_vm)
sigma_sq_k = C_mm_var - np.float(kriging_weights.reshape(1,-1)@c_vm)
#sigma_sq_k = max_cov - np.float(kriging_weights.reshape(1,-1)@c_vm)
mu_k = np.float(np.array(kriging_weights.reshape(1,-1)@(v_cond_var - self.target_mean) + self.target_mean))
if use_sgs == False:
if collect_all == True:
if separation == True:
dv = C_mm_var
if sep_idx == 0:
dm = np.max(training_image[:separation_lim]) - np.min(training_image[:separation_lim])
m_k, idx_nv = separation_obj_1.conditional_lookup(mu_k, sigma_sq_k, dm, dv, scaling = scale_m_i, unit_d = unit_d, return_idx = True)
else:
dm = np.max(training_image[separation_lim:]) - np.min(training_image[separation_lim:])
m_k, idx_nv = separation_obj_2.conditional_lookup(mu_k, sigma_sq_k, dm, dv, scaling = scale_m_i, unit_d = unit_d, return_idx = True)
else:
m_k, idx_nv = self.conditional_lookup(mu_k, sigma_sq_k, dm, dv, scaling = scale_m_i, unit_d = unit_d, return_idx = True)
self.idx_nv_collect.append(idx_nv)
self.kriging_mv_collect.append((mu_k, sigma_sq_k))
else:
if separation == True:
dv = C_mm_var
if sep_idx == 0:
dm = np.max(training_image[:separation_lim]) - np.min(training_image[:separation_lim])
m_k = separation_obj_1.conditional_lookup(mu_k, sigma_sq_k, dm, dv, scaling = scale_m_i, unit_d = unit_d, return_idx = False)
else:
dm = np.max(training_image[separation_lim:]) - np.min(training_image[separation_lim:])
m_k = separation_obj_2.conditional_lookup(mu_k, sigma_sq_k, dm, dv, scaling = scale_m_i, unit_d = unit_d, return_idx = False)
else:
m_k = self.conditional_lookup(mu_k, sigma_sq_k, dm, dv, scaling = scale_m_i, unit_d = unit_d, return_idx = False)
else:
m_k = mu_k
m_DSS[step,realization] = m_k
# Count locations walked for search neighborhood
stepped_previously = np.append(stepped_previously, step)
len_stepped += 1
# Get running sense of size of error compared to prior
if sense_running_error == True:
err_mag = np.log10(float(np.abs((training_image)[step]-m_k)))
err_mag_sum += err_mag
err_mag_avg = float(err_mag_sum/len_stepped)
mt_util.printProgressBar (len(stepped_previously), N_m, err_mag_avg, subject = ' realization nr. %d' % realization, notebook_style = notebook_style)
elif sense_running_error == None:
pass
else:
mt_util.printProgressBar (len(stepped_previously), N_m, subject = ' realization nr. %d' % realization, notebook_style = notebook_style)
# End timing
t1 = time.time()
# Plot statistics of realization
time_average[realization] = (t1-t0)
if time_average[realization] < 60:
print('Run time: %.3f' %(time_average[realization]), 'seconds', '')
elif time_average[realization] < 3600:
print('Run time: %.3f' %(time_average[realization]*60**(-1)), 'minutes', '')
else:
print('Run time: %.3f' %(time_average[realization]*60**(-2)), 'hours', '')
if np.sum(time_average[:(realization+1)])*60**(-1) > 60:
print('Total elapsed time: %.3f' %(np.sum(time_average[:(realization+1)])*60**(-2)), 'hours', '')
else:
print('Total elapsed time: %.3f' %(np.sum(time_average[:(realization+1)])*60**(-1)), 'minutes', '')
print('Variance: %.3f' %np.var(m_DSS[:,realization]))
print('Mean: %.3f' %np.mean(m_DSS[:,realization]))
print('Max: %.3f' %np.max(m_DSS[:,realization]))
print('Min: %.3f' %np.min(m_DSS[:,realization]))
print('Run nr.:', realization+1)
print('')
# Save realizations after each step
np.save("m_DSS_{}".format(save_string), m_DSS[:,:realization])
self.m_DSS = m_DSS
if G is not None:
self.m_DSS_pred = [email protected]_DSS
self.m_DSS_res = observations.reshape(-1,1) - self.m_DSS_pred
rmse_leg = np.sqrt(np.mean(np.power(self.m_DSS_res,2),axis=0))
print("")
print("Seqsim RMSE:\t {}".format(rmse_leg))
# color_rgb = (0.6,0.6,0.6)
# plt.figure()
# for i in np.arange(0,N_sim):
# y,binEdges=np.histogram(self.m_DSS_res[:,[i]],bins=200)
# bincenters = 0.5*(binEdges[1:]+binEdges[:-1])
# if i == 0:
# plt.plot(bincenters,y,'-',color = color_rgb,label='Seqsim')
# else:
# plt.plot(bincenters,y,'-',color = color_rgb)
# plt.xlabel("Radial field residuals [nT]")
# plt.ylabel("Count")
# plt.show()
m_DSS_mean = np.mean(self.m_DSS,axis=-1).reshape(-1,1)@np.ones((1,N_sim))
if N_sim > 1:
self.C_DSS = 1/(N_sim-1)*(self.m_DSS-m_DSS_mean)@(self.m_DSS-m_DSS_mean).T
def realization_to_sh_coeff(self, r_at, set_nmax = None, set_norm = 1, geomag_scale = True):
#self.grid_glq(nmax = self.N_SH, r_at = r_at)
if set_nmax == None:
set_nmax = self.grid_nmax
self.g_spec = []
for i in np.arange(0,self.N_sim):
C_vec, _ = mt_util.sh_expand_glq(self.m_DSS[:,[i]], self.grid_nmax, self.grid_w_shtools, self.grid_zero, set_nmax, set_norm = set_norm, geomag_scale = geomag_scale, geomag_r_at = r_at)
self.g_spec.append(C_vec)
self.g_spec = np.array(self.g_spec).T
self.g_spec_mean = np.mean(self.g_spec,axis=1)
def run_sim_sep(self, N_sim):
import time
import random
kriging_method = "simple"
"""
Possible kriging_method(s):
- simple
"""
"""Number of simulations"""
m_DSS = np.zeros((core.grid_N + lithos.grid_N, N_sim))
time_average = np.zeros((N_sim))
"""save variables"""
idx_nv = list()
lagrange = list()
kriging_mv = list()
rand_paths = list()
invshapes = list()
kriging_weights = list()
kriging_weights_rel_dat = list()
v_cond_vars = list()
lstsq_param = list()
prior_data = np.hstack((core.data,lithos.data))
""" Run sequential simulations"""
for realization in range(0,N_sim):
# Start timing
t0 = time.time()
random.seed(a=None)
np.random.seed()
# Initialize sequential simulation with random start
step_rnd_path = np.arange(core.grid_N + lithos.grid_N)
# Randomize index array to create random path
random.shuffle(step_rnd_path)
"""Run spherical direct sequential simulation"""
idx_v = np.empty([0,],dtype=int)
idx_n = np.empty([0,],dtype=int)
data_min_c = np.min(core.data)
data_max_c = np.max(core.data)
dm_c = data_max_c - data_min_c
dv_c = core.target_var
data_min_l = np.min(lithos.data)
data_max_l = np.max(lithos.data)
dm_l = data_max_l - data_min_l
dv_l = lithos.target_var
stepped_previously = np.empty([0,],dtype=int)
err_mag_sum_c = 0.0
err_mag_sum_l = 0.0
len_walked_c = 0
len_walked_l = 0
len_stepped = 0
# Start random walk
for step in step_rnd_path:
step = step
C_mm = np.empty([0,],dtype=np.longdouble)
C_dd = | np.empty([0,],dtype=np.longdouble) | numpy.empty |
# future
from __future__ import annotations
# stdlib
from typing import Any
from typing import Dict
from typing import List
from typing import Optional
from typing import Sequence
from typing import Tuple
from typing import Union
# third party
from nacl.signing import VerifyKey
import numpy as np
from sympy.ntheory.factor_ import factorint
# relative
from ....core.adp.entity import DataSubjectGroup
from ....core.adp.entity import Entity
from ...adp.publish import publish
from ...adp.vm_private_scalar_manager import VirtualMachinePrivateScalarManager
from ...common.serde.serializable import serializable
from ...tensor.passthrough import PassthroughTensor # type: ignore
from ...tensor.passthrough import is_acceptable_simple_type # type: ignore
from ..broadcastable import is_broadcastable
from .adp_tensor import ADPTensor
SupportedChainType = Union[int, bool, float, np.ndarray, PassthroughTensor]
@serializable(recursive_serde=True)
class IntermediateGammaTensor(PassthroughTensor, ADPTensor):
"""Functionality for tracking differential privacy when individual values
are contributed to by multiple entities. IntermediateGammaTensor differs
from IniitalGammaTensor only in that InitialGammaTensor has additional
functionality in its constructor essential to when one initially begins
tracking metadata across mutliple entities, whereas IntermediateGammaTensor
has a simpler constructor for use when performing operations across one or
more IntermediateGammaTensor objects.
"""
__attr_allowlist__ = [
"term_tensor",
"coeff_tensor",
"bias_tensor",
"scalar_manager",
"child",
"unique_entities",
"n_entities",
]
def __init__(
self,
term_tensor: np.ndarray,
coeff_tensor: np.ndarray,
bias_tensor: np.ndarray,
# min_vals: np.ndarray,
# max_vals: np.ndarray,
scalar_manager: VirtualMachinePrivateScalarManager = VirtualMachinePrivateScalarManager(),
) -> None:
super().__init__(term_tensor)
# EXPLAIN A: if our clipped polynomial is y = clip(mx + b, min=min_vals, max=max_vals)
# EXPLAIN B: if self.child = 5x10
# EXPLAIN A: this is "x"
# EXPLAIN B: this is a 5x10x1
self.term_tensor = term_tensor
# EXPLAIN A: this is "m"
# EXPLAIN B: this is a 5x10x1
self.coeff_tensor = coeff_tensor
# EXPLAIN A: this is "b"
# EXPLAIN B: this is a 5x10
self.bias_tensor = bias_tensor
# EXPLAIN A: this is "min_vals"
# EXPLAIN B: this is a 5x10
# self.min_vals = min_vals
# EXPLAIN A: this is "max_vals"
# EXPLAIN B: this is a 5x10
# self.max_vals = max_vals
self.scalar_manager = scalar_manager
# Unique entities
self.unique_entities: set[Entity] = set()
self.n_entities = 0
for entity in set(self._entities_list()):
if isinstance(entity, Entity):
if entity not in self.unique_entities:
self.unique_entities.add(entity)
self.n_entities += 1
elif isinstance(entity, DataSubjectGroup):
for e in entity.entity_set:
if e not in self.unique_entities:
self.unique_entities.add(e)
self.n_entities += 1
else:
raise Exception(f"{type(entity)}")
@property
def flat_scalars(self) -> List[Any]:
flattened_terms = self.term_tensor.reshape(-1, self.term_tensor.shape[-1])
flattened_coeffs = self.coeff_tensor.reshape(-1, self.coeff_tensor.shape[-1])
flattened_bias = self.bias_tensor.reshape(-1)
# flattened_min_vals = self.min_vals.reshape(-1)
# flattened_max_vals = self.max_vals.reshape(-1)
scalars = list()
for i in range(len(flattened_terms)):
single_poly_terms = flattened_terms[i]
single_poly_coeffs = flattened_coeffs[i]
single_poly_bias = flattened_bias[i]
# single_poly_min_val = flattened_min_vals[i]
# single_poly_max_val = flattened_max_vals[i]
scalar = single_poly_bias
for j in range(len(single_poly_terms)):
term = single_poly_terms[j]
coeff = single_poly_coeffs[j]
for prime, n_times in factorint(term).items():
input_scalar = self.scalar_manager.prime2symbol[prime]
right = input_scalar * n_times * coeff
scalar = scalar + right
scalars.append(scalar)
return scalars
def _values(self) -> np.array:
"""WARNING: DO NOT MAKE THIS AVAILABLE TO THE POINTER!!!
DO NOT ADD THIS METHOD TO THE AST!!!
"""
return np.array(list(map(lambda x: x.value, self.flat_scalars))).reshape(
self.shape
)
def _max_values(self) -> np.array:
"""WARNING: DO NOT MAKE THIS AVAILABLE TO THE POINTER!!!
DO NOT ADD THIS METHOD TO THE AST!!!
"""
return np.array(list(map(lambda x: x.max_val, self.flat_scalars))).reshape(
self.shape
)
def _min_values(self) -> np.array:
"""WARNING: DO NOT MAKE THIS AVAILABLE TO THE POINTER!!!
DO NOT ADD THIS METHOD TO THE AST!!!
"""
return np.array(list(map(lambda x: x.min_val, self.flat_scalars))).reshape(
self.shape
)
def _entities_list(self) -> list:
"""WARNING: DO NOT MAKE THIS AVAILABLE TO THE POINTER!!!
DO NOT ADD THIS METHOD TO THE AST!!!
"""
output_entities = []
for flat_scalar in self.flat_scalars:
# TODO: This will fail if the nested entity is any deeper than 2 levels- i.e. [A, [A, [A, B]]]. Recursive?
combined_entities = DataSubjectGroup()
for row in flat_scalar.input_entities:
if isinstance(row, Entity) or isinstance(row, DataSubjectGroup):
combined_entities += row
elif isinstance(row, list):
for i in row:
if isinstance(i, Entity) or isinstance(i, DataSubjectGroup):
combined_entities += i
else:
raise Exception(f"Not implemented for i of type:{type(i)}")
else:
raise Exception(f"No plans for row type:{type(row)}")
output_entities.append(combined_entities)
return output_entities
def _entities(self) -> np.array:
"""WARNING: DO NOT MAKE THIS AVAILABLE TO THE POINTER!!!
DO NOT ADD THIS METHOD TO THE AST!!!
"""
output_entities = []
for flat_scalar in self.flat_scalars:
# TODO: This will fail if the nested entity is any deeper than 2 levels- i.e. [A, [A, [A, B]]]. Recursive?
combined_entities = DataSubjectGroup()
for row in flat_scalar.input_entities:
if isinstance(row, Entity) or isinstance(row, DataSubjectGroup):
combined_entities += row
elif isinstance(row, list):
for i in row:
if isinstance(i, Entity) or isinstance(i, DataSubjectGroup):
combined_entities += i
else:
raise Exception(f"Not implemented for i of type:{type(i)}")
else:
raise Exception(f"No plans for row type:{type(row)}")
output_entities.append(combined_entities)
return np.array(output_entities).reshape(self.shape)
def __gt__(self, other: Union[np.ndarray, IntermediateGammaTensor]) -> Any:
if isinstance(other, np.ndarray):
if is_broadcastable(self.shape, other.shape):
# relative
from .initial_gamma import InitialGammaTensor
vals = self._values()
tensor = InitialGammaTensor(
values=vals > other,
min_vals=np.zeros_like(vals),
max_vals=np.ones_like(vals),
entities=self._entities(),
)
else:
raise Exception(
f"Tensor shapes not compatible: {self.shape} and {other.shape}"
)
elif isinstance(other, IntermediateGammaTensor):
if is_broadcastable(self.shape, other.shape):
# relative
from .initial_gamma import InitialGammaTensor
self_vals = self._values()
other_vals = other._values()
tensor = InitialGammaTensor(
values=self_vals > other_vals,
min_vals=np.zeros_like(self_vals),
max_vals=np.ones_like(self_vals),
entities=self._entities() + other._entities(),
)
else:
raise Exception(
f"Tensor shapes not compatible: {self.shape} and {other.shape}"
)
else:
raise NotImplementedError
return tensor
def __lt__(self, other: Union[np.ndarray, IntermediateGammaTensor]) -> Any:
if isinstance(other, np.ndarray):
if is_broadcastable(self.shape, other.shape):
# relative
from .initial_gamma import InitialGammaTensor
vals = self._values()
tensor = InitialGammaTensor(
values=vals < other,
min_vals=np.zeros_like(vals),
max_vals=np.ones_like(vals),
entities=self._entities(),
)
else:
raise Exception(
f"Tensor shapes not compatible: {self.shape} and {other.shape}"
)
elif isinstance(other, IntermediateGammaTensor):
if is_broadcastable(self.shape, other.shape):
# relative
from .initial_gamma import InitialGammaTensor
self_vals = self._values()
other_vals = other._values()
tensor = InitialGammaTensor(
values=self_vals < other_vals,
min_vals=np.zeros_like(self_vals),
max_vals=np.ones_like(self_vals),
entities=self._entities() + other._entities(),
)
else:
raise Exception(
f"Tensor shapes not compatible: {self.shape} and {other.shape}"
)
else:
raise NotImplementedError
return tensor
def __eq__(self, other: Union[np.ndarray, IntermediateGammaTensor]) -> Any:
if isinstance(other, np.ndarray):
if is_broadcastable(self.shape, other.shape):
# relative
from .initial_gamma import InitialGammaTensor
vals = self._values()
tensor = InitialGammaTensor(
values=not (vals < other) and not (vals > other),
max_vals= | np.ones_like(vals) | numpy.ones_like |
#!/usr/bin/env python
import numpy as np
from tqdm import tqdm
from astropy.constants import G as Ggrav
from .low_level_utils import fast_dist
G = Ggrav.to('kpc Msun**-1 km**2 s**-2').value
def all_profiles(bins, positions, velocities, masses, two_dimensional=False, zcut=None,
ages=None, pbar_msg='Making profiles"', nexpr=False):
"""
assumes all positions and velocities are rotated in the same way, such
that the angular momentum axis aligns with the z axis
if two_dimensional == False, then compute:
M(<r), M(r), rho = M(r)/dV, Vcirc = sqrt(GM(<r)/r), mag J(r), mag J(<r), J_z(r), J_z(<r)
if two_dimensional == True, then compute:
M(<R), M(R), rho = M(R)/dA, Vcirc = mean(vx**2 + vy**2), mag J(R), mag J(<R), J_z(R), J_z(<R)
:bins : array-like : sorted (from small to large) bin edges to use
:positions : array-like : particle positions, rotated such that z aligns with angular momentum axis
:velocities : array-like : particle velocities, rotated in the same way as the positions
:masses : array-like : particle masses, in the same order as positions and velocities
:two_dimensional : bool : whether or not to do 2D profiles
:pbar_msg: str : what to print for the pbar (total mass and number of particles is appended)
:nexpr : bool : whether or not to try to use numexpr to try to speed up the calculation
"""
if nexpr:
from numexpr import evaluate
print("Using numexpr for the masking and summing masses")
# work from outside in, throwing away particles as I no longer need them
assert positions.shape[0] == velocities.shape[0] == masses.shape[0]
m_of_r = np.empty(bins.size)
J_of_r = np.empty(bins.size)
Jz_of_r = np.empty(bins.size)
Jz_inside_r = np.empty(bins.size)
JinsideR = np.empty(bins.size)
specJinsideR = np.zeros(bins.size)
specJ_of_r = np.zeros(bins.size)
specJz_of_r = np.zeros(bins.size)
specJz_insideR = np.zeros(bins.size)
if ages is not None:
age_of_r = np.zeros(bins.size)
density = np.empty_like(m_of_r)
if two_dimensional:
vcirc = np.zeros(bins.size)
if two_dimensional:
x, y, z = positions.T
# distances are in the plane of the galaxy
distances = np.sqrt(x**2 + y**2)
else:
distances = fast_dist(positions) # center assumed to be at (0,0,0)
# throw away any particles beyond my last bin edge
msk = distances <= bins.max()
if two_dimensional:
msk = msk & (np.abs(z) <= zcut)
positions = positions[msk]
velocities = velocities[msk]
masses = masses[msk]
distances = distances[msk]
if ages is not None:
ages = ages[msk]
if two_dimensional:
x = x[msk]
y = y[msk]
# compute (angular) momenta for the particles:
# velocities should already have the halo at
pvec = (velocities.T*masses).T
# J = r cross p, and pos is assumed to have the halo at 0,0,0
Jvec = np.cross(positions, pvec)
del pvec
Jz = Jvec[:, 2]
if two_dimensional:
# calculate circular velocities:
# velocities in the plane of the disk
vx, vy = velocities[:, 0], velocities[:, 1]
V = np.vstack((vx, vy)).T # velocity vector in the plane of the disk
R = | np.vstack((x, y)) | numpy.vstack |
import sys
import os
import pickle
import cv2
import numpy as np
CAFFE_PYTHON_PATH = os.path.join(os.path.dirname(__file__), "../python")
sys.path.insert(0, CAFFE_PYTHON_PATH)
import caffe
from Dataset import GetDataset
from ACT_utils import *
from copy import deepcopy
K = 6
IMGSIZE = 300
MEAN = np.array([[[104, 117, 123]]], dtype=np.float32)
NFLOWS = 5
def extract_tubelets(dname, gpu=-1, redo=False):
"""Extract the tubelets for a given dataset
args:
- dname: dataset name (example: 'JHMDB')
- gpu (default -1): use gpu given in argument, or use cpu if -1
- redo: wheter or not to recompute already computed files
save a pickle file for each frame
the file contains a tuple (dets, dets_all)
- dets is a numpy array with 2+4*K columns containing the tubelets starting at this frame after per-class nms at 0.45 and thresholding the scores at 0.01
the columns are <label> <score> and then <x1> <y1> <x2> <y2> for each of the frame in the tubelet
- dets_all contains the tubelets obtained after a global nms at 0.7 and thresholding the scores at 0.01
it is a numpy arrray with 4*K + L + 1 containing the coordinates of the tubelets and the scores for all labels
note: this version is inefficient: it is better to estimate the per-frame features once
"""
d = GetDataset(dname)
if gpu >= 0:
caffe.set_mode_gpu()
caffe.set_device(gpu)
model_dir = os.path.join(os.path.dirname(__file__), '../models/ACT-detector/', dname)
output_dir = os.path.join(os.path.dirname(__file__), '../results/ACT-detector/', dname)
# load the RGB network
rgb_proto = os.path.join(model_dir, "deploy_RGB.prototxt")
rgb_model = os.path.join(model_dir, "RGB.caffemodel")
net_rgb = caffe.Net(rgb_proto, caffe.TEST, weights=rgb_model)
# load the FLOW5 network
flo_proto = os.path.join(model_dir, "deploy_FLOW5.prototxt")
flo_model = os.path.join(model_dir, "FLOW5.caffemodel")
net_flo = caffe.Net(flo_proto, caffe.TEST, weights=flo_model)
vlist = d.test_vlist()
for iv, v in enumerate(vlist):
print("Processing video {:d}/{:d}: {:s}".format( iv+1, len(vlist), v))
h, w = d.resolution(v)
# network output is normalized between 0,1 ; so we will multiply it by the following array
resolution_array = np.array([w,h,w,h]*K, dtype=np.float32)
# now process each frame
for i in range(1, 1 + d.nframes(v) - K + 1):
outfile = os.path.join(output_dir, d.frame_format(v,i) + ".pkl")
# skip if already computed
if os.path.isfile(outfile) and not redo:
continue
# read the frames for the forward
kwargs_rgb = {}
kwargs_flo = {}
for j in range(K):
im = cv2.imread(d.imfile(v, i + j))
if im is None:
print("Image {:s} does not exist".format(d.imfile(v, i+j)))
return
imscale = cv2.resize(im, (IMGSIZE, IMGSIZE), interpolation=cv2.INTER_LINEAR)
kwargs_rgb['data_stream' + str(j)] = np.transpose(imscale-MEAN, (2, 0, 1))[None, :, :, :]
imf = [cv2.imread(d.flowfile(v, min(d.nframes(v), i + j + iflow))) for iflow in range(NFLOWS)]
if np.any(imf) is None:
print("Flow image {:s} does not exist".format(d.flowfile(v, i+j)))
return
imscalef = [cv2.resize(im, (IMGSIZE, IMGSIZE), interpolation=cv2.INTER_LINEAR) for im in imf]
timscale = [np.transpose(im-MEAN, (2, 0, 1))[None, :, :, :] for im in imscalef]
kwargs_flo['data_stream' + str(j) + 'flow'] = np.concatenate(timscale, axis=1)
# compute rgb and flow scores
# two forward passes: one for the rgb and one for the flow
net_rgb.forward(end="mbox_conf_flatten", **kwargs_rgb) # forward of rgb with confidence and regression
net_flo.forward(end="mbox_conf_flatten", **kwargs_flo) # forward of flow5 with confidence and regression
# compute late fusion of rgb and flow scores (keep regression from rgb)
# use net_rgb for standard detections, net_flo for having all boxes
scores = 0.5 * (net_rgb.blobs['mbox_conf_flatten'].data + net_flo.blobs['mbox_conf_flatten'].data)
net_rgb.blobs['mbox_conf_flatten'].data[...] = scores
net_flo.blobs['mbox_conf_flatten'].data[...] = scores
net_flo.blobs['mbox_loc'].data[...] = net_rgb.blobs['mbox_loc'].data
# two forward passes, only for the last layer
# dets is the detections after per-class NMS and thresholding (stardard)
# dets_all contains all the scores and regressions for all tubelets
dets = net_rgb.forward(start='detection_out')['detection_out'][0, 0, :, 1:]
dets_all = net_flo.forward(start='detection_out_full')['detection_out_full'][0, 0, :, 1:]
# parse detections with per-class NMS
if dets.shape[0] == 1 and np.all(dets == -1):
dets = np.empty((0, dets.shape[1]), dtype=np.float32)
dets[:, 2:] *= resolution_array # network output was normalized in [0..1]
dets[:, 0] -= 1 # label 0 was background, come back to label in [0..nlabels-1]
dets[:, 2::2] = np.maximum(0, np.minimum(w, dets[:, 2::2]))
dets[:, 3::2] = np.maximum(0, np.minimum(h, dets[:, 3::2]))
# parse detections with global NMS at 0.7 (top 300)
# coordinates were normalized in [0..1]
dets_all[:, 0:4*K] *= resolution_array
dets_all[:, 0:4*K:2] = np.maximum(0, np.minimum(w, dets_all[:, 0:4*K:2]))
dets_all[:, 1:4*K:2] = np.maximum(0, np.minimum(h, dets_all[:, 1:4*K:2]))
idx = nms_tubelets(np.concatenate((dets_all[:, :4*K], np.max(dets_all[:, 4*K+1:], axis=1)[:, None]), axis=1), 0.7, 300)
dets_all = dets_all[idx, :]
# save file
if not os.path.isdir(os.path.dirname(outfile)):
os.system('mkdir -p ' + os.path.dirname(outfile))
with open(outfile, 'wb') as fid:
pickle.dump((dets, dets_all), fid)
def load_frame_detections(d, vlist, dirname, nms):
if isinstance(d, str):
d = GetDataset(d)
alldets = [] # list of numpy array with <video_index> <frame_index> <ilabel> <score> <x1> <y1> <x2> <y2>
for iv, v in enumerate(vlist):
h,w = d.resolution(v)
# aggregate the results for each frame
vdets = {i: np.empty((0,6), dtype=np.float32) for i in range(1, 1 + d.nframes(v))} # x1, y1, x2, y2, score, ilabel
# load results for each starting frame
for i in range(1, 1 + d.nframes(v) - K + 1):
resname = os.path.join(dirname, d.frame_format(v,i) + '.pkl')
if not os.path.isfile(resname):
print("ERROR: Missing extracted tubelets "+resname)
sys.exit()
with open(resname, 'rb') as fid:
dets, _ = pickle.load(fid)
if dets.size == 0:
continue
for k in range(K):
vdets[i+k] = np.concatenate( (vdets[i+k],dets[:,np.array([2+4*k,3+4*k,4+4*k,5+4*k,1,0])] ), axis=0)
# Perform NMS in each frame
for i in vdets:
idx = np.empty((0,), dtype=np.int32)
for ilabel in range(d.nlabels):
a = np.where(vdets[i][:,5] == ilabel)[0]
if a.size == 0:
continue
idx = np.concatenate((idx, a[nms2d(vdets[i][vdets[i][:, 5] == ilabel, :5], nms)]), axis=0)
if idx.size == 0:
continue
alldets.append(np.concatenate((iv * np.ones((idx.size, 1), dtype=np.float32), i * np.ones((idx.size, 1), dtype=np.float32), vdets[i][idx, :][:, np.array([5, 4, 0, 1, 2, 3], dtype=np.int32)]), axis=1))
return np.concatenate(alldets, axis=0)
def frameAP(dname, th=0.5, redo=False):
d = GetDataset(dname)
dirname = os.path.join(os.path.dirname(__file__), '../results/ACT-detector/', dname)
eval_file = os.path.join(dirname, "frameAP{:g}.pkl".format(th))
if os.path.isfile(eval_file) and not redo:
with open(eval_file, 'rb') as fid:
res = pickle.load(fid)
else:
vlist = d.test_vlist()
# load per-frame detections
alldets = load_frame_detections(d, vlist, dirname, 0.3)
res = {}
# compute AP for each class
for ilabel,label in enumerate(d.labels):
# detections of this class
detections = alldets[alldets[:, 2] == ilabel, :]
# load ground-truth of this class
gt = {}
for iv, v in enumerate(vlist):
tubes = d.gttubes(v)
if not ilabel in tubes:
continue
for tube in tubes[ilabel]:
for i in range(tube.shape[0]):
k = (iv, int(tube[i, 0]))
if not k in gt:
gt[k] = []
gt[k].append(tube[i, 1:5].tolist())
for k in gt:
gt[k] = np.array( gt[k] )
# pr will be an array containing precision-recall values
pr = np.empty((detections.shape[0] + 1, 2), dtype=np.float32)# precision,recall
pr[0, 0] = 1.0
pr[0, 1] = 0.0
fn = sum([g.shape[0] for g in gt.values()]) # false negatives
fp = 0 # false positives
tp = 0 # true positives
for i, j in enumerate(np.argsort(-detections[:,3])):
k = (int(detections[j,0]), int(detections[j,1]))
box = detections[j, 4:8]
ispositive = False
if k in gt:
ious = iou2d(gt[k], box)
amax = np.argmax(ious)
if ious[amax] >= th:
ispositive = True
gt[k] = np.delete(gt[k], amax, 0)
if gt[k].size == 0:
del gt[k]
if ispositive:
tp += 1
fn -= 1
else:
fp += 1
pr[i+1, 0] = float(tp) / float(tp + fp)
pr[i+1, 1] = float(tp) / float(tp + fn)
res[label] = pr
# save results
with open(eval_file, 'wb') as fid:
pickle.dump(res, fid)
# display results
ap = 100*np.array([pr_to_ap(res[label]) for label in d.labels])
print("frameAP")
for il, _ in enumerate(d.labels):
print("{:20s} {:8.2f}".format('', ap[il]))
print("{:20s} {:8.2f}".format("mAP", np.mean(ap)))
print("")
def frameAP_error(dname, th=0.5, redo=False):
d = GetDataset(dname)
dirname = os.path.join(os.path.dirname(__file__), '../results/ACT-detector/', dname)
eval_file = os.path.join(dirname, "frameAP{:g}ErrorAnalysis.pkl".format(th))
if os.path.isfile(eval_file) and not redo:
with open(eval_file, 'rb') as fid:
res = pickle.load(fid)
else:
vlist = d.test_vlist()
# load per-frame detections
alldets = load_frame_detections(d, vlist, dirname, 0.3)
res = {}
# compute AP for each class
for ilabel,label in enumerate(d.labels):
# detections of this class
detections = alldets[alldets[:, 2] == ilabel, :]
gt = {}
othergt = {}
labellist = {}
for iv, v in enumerate(vlist):
tubes = d.gttubes(v)
labellist[v] = tubes.keys()
for il in tubes:
for tube in tubes[il]:
for i in range(tube.shape[0]):
k = (iv, int(tube[i, 0]))
if il == ilabel:
if k not in gt:
gt[k] = []
gt[k].append(tube[i, 1:5].tolist())
else:
if k not in othergt:
othergt[k] = []
othergt[k].append(tube[i, 1:5].tolist())
for k in gt:
gt[k] = np.array(gt[k])
for k in othergt:
othergt[k] = np.array(othergt[k])
dupgt = deepcopy(gt)
# pr will be an array containing precision-recall values and 4 types of errors:
# localization, classification, timing, others
pr = np.empty((detections.shape[0] + 1, 6), dtype=np.float32)# precision, recall
pr[0, 0] = 1.0
pr[0, 1:] = 0.0
fn = sum([g.shape[0] for g in gt.values()]) # false negatives
fp = 0 # false positives
tp = 0 # true positives
EL = 0 # localization errors
EC = 0 # classification error: overlap >=0.5 with an another object
EO = 0 # other errors
ET = 0 # timing error: the video contains the action but not at this frame
for i, j in enumerate(np.argsort(-detections[:,3])):
k = (int(detections[j, 0]), int(detections[j,1]))
box = detections[j, 4:8]
ispositive = False
if k in dupgt:
if k in gt:
ious = iou2d(gt[k], box)
amax = np.argmax(ious)
if k in gt and ious[amax] >= th:
ispositive = True
gt[k] = | np.delete(gt[k], amax, 0) | numpy.delete |
#!/usr/bin/env python
"""
Curves, tracks, skeletons connecting surface mesh vertices.
Authors:
- <NAME>, 2012-2016 (<EMAIL>) http://binarybottle.com
- <NAME>, 2012 (<EMAIL>)
Copyright 2016, Mindboggle team (http://mindboggle.info), Apache v2.0 License
"""
def connect_points_erosion(S, neighbor_lists, outer_anchors, inner_anchors=[],
values=[], erode_ratio=0.1, erode_min_size=10,
save_steps=[], save_vtk='', background_value=-1,
verbose=False):
"""
Connect mesh vertices with a skeleton of 1-vertex-thick curves by erosion.
This algorithm iteratively removes simple topological points and endpoints,
optionally in order of lowest to highest values.
Parameters
----------
S : numpy array of integers
values for all vertices (disregard background values)
outer_anchors : list of integers
indices of vertices to connect
inner_anchors : list of integers
more vertices to connect; they are removed if they result in endpoints
neighbor_lists : list of lists of integers
each list contains indices to neighboring vertices for each vertex
values : numpy array of floats
values for S elements, to optionally remove points
in order of lowest to highest values
erode_ratio : float
fraction of indices to test for removal at each iteration (if values)
erode_min_size : integer
minimum number of vertices when considering erode_ratio
save_steps : list of integers (optional)
iterations at which to save incremental VTK file
save_vtk : string
name of VTK file to transfer incremental values (if save_steps)
background_value : integer or float
background value
verbose : bool
print statements?
Returns
-------
skeleton : list of integers
indices to vertices of skeleton
Examples
--------
>>> # Extract a skeleton to connect endpoints in a fold:
>>> import numpy as np
>>> from mindboggle.guts.paths import connect_points_erosion
>>> from mindboggle.guts.paths import find_outer_endpoints
>>> from mindboggle.mio.vtks import read_scalars, read_vtk
>>> from mindboggle.guts.compute import median_abs_dev
>>> from mindboggle.guts.paths import find_max_values
>>> from mindboggle.guts.mesh import find_neighbors_from_file
>>> from mindboggle.mio.fetch_data import prep_tests
>>> urls, fetch_data = prep_tests()
>>> curv_file = fetch_data(urls['left_mean_curvature'], '', '.vtk')
>>> depth_file = fetch_data(urls['left_travel_depth'], '', '.vtk')
>>> folds_file = fetch_data(urls['left_folds'], '', '.vtk')
>>> points, f1,f2,f3, curvs, f4,f5,f6 = read_vtk(curv_file, True,True)
>>> depths, name = read_scalars(depth_file, True, True)
>>> folds, name = read_scalars(folds_file, True, True)
>>> values = depths * curvs
>>> [np.float("{0:.{1}f}".format(x, 5)) for x in values[0:5]]
[-0.11778, -0.35642, -0.80759, -0.25654, -0.04411]
>>> neighbor_lists = find_neighbors_from_file(curv_file)
>>> background_value = -1
>>> # Limit number of folds to speed up the test:
>>> limit_folds = True
>>> if limit_folds:
... fold_numbers = [4] #[4, 6]
... indices = [i for i,x in enumerate(folds) if x in fold_numbers]
... i0 = [i for i,x in enumerate(folds) if x not in fold_numbers]
... folds[i0] = background_value
... else:
... indices = range(len(values))
>>> # Outer anchors:
>>> min_separation = 10
>>> verbose = False
>>> outer_anchors, tracks = find_outer_endpoints(indices, neighbor_lists,
... values, depths, min_separation,
... background_value, verbose)
>>> outer_anchors[0:10]
[50324, 66986, 75661]
>>> # Inner anchors:
>>> values0 = [x for x in values if x > 0]
>>> thr = np.median(values0) + 2 * median_abs_dev(values0)
>>> inner_anchors = find_max_values(points, values, min_separation, thr)
>>> inner_anchors[0:10]
[61455, 41761, 67978, 72621, 78546, 40675, 73745, 98736, 125536, 119813]
>>> erode_ratio = 0.10
>>> erode_min_size = 10
>>> save_steps = [] #list(range(0,500,50))
>>> save_vtk = depth_file
>>> S = np.copy(folds)
>>> skeleton = connect_points_erosion(S, neighbor_lists,
... outer_anchors, inner_anchors, values, erode_ratio, erode_min_size,
... save_steps, save_vtk, background_value, verbose)
>>> skeleton[0:10]
[50324, 50333, 50339, 51552, 51560, 52707, 52716, 52724, 52725, 53893]
Write out vtk file and view (skip test):
>>> from mindboggle.mio.plots import plot_surfaces # doctest: +SKIP
>>> from mindboggle.mio.vtks import rewrite_scalars # doctest: +SKIP
>>> folds[skeleton] = 10 # doctest: +SKIP
>>> folds[outer_anchors] = 15 # doctest: +SKIP
>>> rewrite_scalars(depth_file, 'connect_points_erosion.vtk',
... folds, 'skeleton', folds, background_value) # doctest: +SKIP
>>> plot_surfaces('connect_points_erosion.vtk') # doctest: +SKIP
"""
import numpy as np
from mindboggle.guts.mesh import topo_test, extract_edge, find_endpoints
from mindboggle.guts.segment import segment_regions
# Make sure arguments are numpy arrays:
if not isinstance(S, np.ndarray):
S = np.array(S)
erode_by_value = False
if len(values) and 0 <= erode_ratio < 1:
erode_by_value = True
if not isinstance(values, np.ndarray):
values = np.array(values)
keep = outer_anchors[:]
keep.extend(inner_anchors)
remove_endpoints = True
if save_steps:
from mindboggle.mio.vtks import rewrite_scalars
S0 = S.copy()
# ------------------------------------------------------------------------
# Iteratively remove simple points:
# ------------------------------------------------------------------------
if verbose:
print(' Remove up to {0} of edge vertices per iteration'.
format(erode_ratio))
complex = []
count = -1
exist_simple = True
while exist_simple:
exist_simple = False
if verbose or save_steps:
count += 1
# --------------------------------------------------------------------
# Only consider updating vertices that are on the edge of the
# region and are not among the indices to keep or known simple points:
# --------------------------------------------------------------------
indices = | np.where(S != background_value) | numpy.where |
"""
Pyhton DLIS file reader
<NAME> - <EMAIL>
July 2016
PREFACE:
American Petroleum Institute (API) Standard RP66 Version 1 (RP66 V1),
published in May 1991, specified a format for digital well log data,
called Digital Log Interchange Standard (DLIS).
RP66 V1 publication was under jurisdiction of API until June 1998,
when Petrotechnical Open Software Corporation (POSC) accepted its
stewardship.
In November 2006, POSC re-brands itself as Energistics.
PURPOSE:
This software was created to read DLIS files.
At this time only DLIS Version 1 (RP66 V1) is supported.
SOURCES:
This code was developed based on Energistics RP66 V1 standard:
http://w3.energistics.org/RP66/V1/Toc/main.html
USAGE:
(1) To read a DLIS file into memory, just use:
dlis = DLISFile() (mandatory)
dlis.read(filename) (mandatory)
(2) An example of usage (just a example) can be shown with:
dlis.print_logical_file() (optional)
The function above is just a taste of this DLIS reader, it
produces some result like this:
Logical File: 0
1&0&B61441
#1
0&0&INDEX : 1640.375 m
1&0&DT : -999.25 us/ft
1&0&GR : 51.84400177 gAPI
1&0&ILD : 0.0189999993891 ohm.m
1&0&CALI : 12.3409996033 in
1&0&RHOB : 4.29400014877 g/cm3
1&0&NPHI : 0.675999999046 m3/m3
#2
0&0&INDEX : 1640.5 m
1&0&DT : -999.25 us/ft
1&0&GR : 55.9160003662 gAPI
1&0&ILD : 0.0189999993891 ohm.m
1&0&CALI : 12.3509998322 in
1&0&RHOB : 4.29400014877 g/cm3
1&0&NPHI : 0.65030002594 m3/m3
...
#n
(3) For a real usage, use these data structures:
- dlis.data: a list of Logical Wells data. Each Logical Well data
is an OrderedDict containing object name as key and
another OrderedDict as object values, that values are
a OrderedDict too containing data index as key
(e.g #1, #2, #n) and a list of values as a dict value.
This list of values are the real log data values.
The structure is illustrated below.
-> Logical Well Data 1
-> Logical Well Data 2
--> (object_name_1, object_dict_1), where object_dict_1 is:
---> (data_index_1, list_of_values_1)
---> (data_index_2, list_of_values_2)
---> (data_index_n, list_of_values_n)
--> (object_name_2, object_dict_2)
--> (object_name_n, object_dict_n)
-> Logical Well Data n
- dlis.data_props: a list of Logical Wells properties. Each Logical
Well properties is an OrderedDict containing object
name as key and another OrderedDict as values
**** (????) - dlis.SUL: a list of well parameters (header parameters).
- dlis.file_header = None
- dlis.origin = None
- dlis.parameter = None
- dlis.frame = None
- dlis.channel = None
"""
import os
import struct
from collections import OrderedDict
import numpy as np
import app
#from multiprocessing import Process, Queue
#import threading
#import utils
def _get_value(data, format_, big_endian=True):
big = ''
if big_endian:
big = '>'
format_ = big + format_
try:
# print()
# print(data, type(data))
n = struct.unpack(format_, data)
# print(n)
# print(n[0], type(n[0]))
# print()
return n[0]
except Exception:
raise
def get_from_list(data_list, start_offset, code, size=None):
code_spec = RepresentationCodes.get_code(code)
# print()
# print('\nget_from_list', start_offset, code, code_spec)
if code_spec is None:
msg = 'Code ' + str(code) + ' is not recognized.'
raise Exception(msg)
special = code_spec.get('special')
if special is None:
if code_spec.get('size') != "variable":
return start_offset+code_spec.get('size'), \
_get_value(data_list[start_offset:start_offset+\
code_spec.get('size')],\
code_spec.get('format')
)
else:
raise Exception()
if special:
if code == 1:
raise Exception()
'''
v1 = ord(data_list[start_offset:start_offset+1])
v2 = ord(data_list[start_offset+1:start_offset+2])
result = bin(v1)[2:].zfill(8)
result += bin(v2)[2:].zfill(8)
fraction = result[1:12]
exponent = result[12:16]
if result[0] == '0':
exponent = int(exponent, 2)
fraction = int(fraction, 2) / 2. ** 23
value = fraction * 2. ** (exponent)
else:
converted_exponent = ''
for i in range(8):
if exponent[i] == '0':
converted_exponent += '1'
else:
converted_exponent += '0'
exponent = int(converted_exponent, 2)
converted_fraction = ''
achou = False
for i in range(22, -1, -1):
if achou:
if fraction[i] == '0':
converted_fraction = '1' + converted_fraction
else:
converted_fraction = '0' + converted_fraction
else:
converted_fraction = fraction[i] + converted_fraction
if fraction[i] == '1':
achou = True
fraction = int(converted_fraction, 2) / 2. ** 23
fraction = fraction * (-1)
value = fraction * 2. ** (exponent - 128)
return start_offset+2, value
'''
elif code == 2:
values = []
for i in range(4):
v = ord(data_list[start_offset+i:start_offset+i+1])
values.append(v)
result = ''
for value in values:
result += bin(value)[2:].zfill(8)
exponent = result[1:9]
mantissa = result[9:32]
exponent = int(exponent, 2)
mantissa = int(mantissa, 2) / 2. ** 23
if result[0] == '1':
value = -(1 + mantissa) * 2. ** (exponent - 127)
else:
value = (1 + mantissa) * 2. ** (exponent - 127)
return start_offset+4, value
elif code == 3:
new_offset, V = get_from_list(data_list, start_offset, 2) # FSINGL
new_offset, A = get_from_list(data_list, new_offset, 2) # FSINGL
# V is a nominal value with a confidence interval of [V - A, V + A]
return new_offset, V, A
elif code == 4:
new_offset, V = get_from_list(data_list, start_offset, 2) # FSINGL
new_offset, A = get_from_list(data_list, new_offset, 2) # FSINGL
new_offset, B = get_from_list(data_list, new_offset, 2) # FSINGL
# V is a nominal value with a confidence interval of [V - A, V + B]
return new_offset, V, A, B
elif code == 5:
values = []
for i in range(4):
v = ord(data_list[start_offset+i:start_offset+i+1])
values.append(v)
result = ''
for value in values:
result += bin(value)[2:].zfill(8)
exponent = result[1:8]
mantissa = result[8:32]
exponent = int(exponent, 2)
mantissa = int(mantissa, 2)
if result[0] == '1':
value = -1 * mantissa * 16. ** (exponent - 64)
else:
value = mantissa * 16. ** (exponent - 64)
return start_offset+4, value
#
elif code == 6:
raise Exception('code == 6!!!')
#
elif code == 7:
values = []
for i in range(8):
v = ord(data_list[start_offset+i:start_offset+i+1])
values.append(v)
result = ''
for value in values:
result += bin(value)[2:].zfill(8)
exponent = result[1:12]
mantissa = result[12:64]
exponent = int(exponent, 2)
mantissa = int(mantissa, 2)
if result[0] == '1':
value = -1 * (1 + mantissa) * 2. ** (exponent - 1023)
else:
value = (1 + mantissa) * 2. ** (exponent - 1023)
return start_offset+8, value
elif code == 8:
new_offset, V = get_from_list(data_list, start_offset, 7) # FDOUBL
new_offset, A = get_from_list(data_list, new_offset, 7) # FDOUBL
# V is a nominal value with a confidence interval of [V - A, V + A]
return new_offset, V, A
elif code == 9:
new_offset, V = get_from_list(data_list, start_offset, 7) # FDOUBL
new_offset, A = get_from_list(data_list, new_offset, 7) # FDOUBL
new_offset, B = get_from_list(data_list, new_offset, 7) # FDOUBL
# V is a nominal value with a confidence interval of [V - A, V + B]
return new_offset, V, A, B
elif code == 10:
new_offset, R = get_from_list(data_list, start_offset, 2) # FSINGL
new_offset, I = get_from_list(data_list, new_offset, 2) # FSINGL
# Value = R + i* I, i = (-1)1/2
return new_offset, R, I
elif code == 11:
new_offset, R = get_from_list(data_list, start_offset, 7) # FDOUBL
new_offset, I = get_from_list(data_list, new_offset, 7) # FDOUBL
# Value = R + i* I, i = (-1)1/2
return new_offset, R, I
elif code == 18 or code == 22:
#print data_list[start_offset:start_offset+1]
try:
bin_vec = bin(ord(data_list[start_offset:start_offset+1]))[2:].zfill(8)
except Exception:
print('start_offset:', start_offset, len(data_list))
raise Exception('Verificar IndexError')
if bin_vec[0] == '0':
return start_offset+1, int(bin_vec, 2)
else:
if bin_vec[1] == '0':
bin_vec = '0' + bin_vec[1:]
bin_vec += bin(ord(data_list[start_offset+1:start_offset+2]))[2:].zfill(8)
return start_offset+2, int(bin_vec, 2)
else:
bin_vec = '00' + bin_vec[2:]
bin_vec += bin(ord(data_list[start_offset+1:start_offset+2]))[2:].zfill(8)
bin_vec += bin(ord(data_list[start_offset+2:start_offset+3]))[2:].zfill(8)
bin_vec += bin(ord(data_list[start_offset+3:start_offset+4]))[2:].zfill(8)
return start_offset+4, int(bin_vec, 2)
elif code == 19 or code == 27:
new_offset, value = get_from_list(data_list, start_offset, 15) # USHORT
return new_offset+value, \
data_list[new_offset:new_offset+value].decode("utf-8")
elif code == 20:
new_offset, value = get_from_list(data_list, start_offset, 18) # UVARI
return new_offset+value, \
data_list[new_offset:new_offset+value].decode("utf-8")
elif code == 21:
dtime = OrderedDict()
new_offset, year = get_from_list(data_list, start_offset, 15) # USHORT
year = 1900 + year
dtime['Y'] = year
v1 = ord(data_list[new_offset:new_offset+1])
new_offset += 1
result = bin(v1)[2:].zfill(8)
tz = result[0:4]
m = result[4:8]
dtime['TZ'] = tz
dtime['M'] = m
new_offset, day = get_from_list(data_list, new_offset, 15) # USHORT
dtime['D'] = day
new_offset, hours = get_from_list(data_list, new_offset, 15) # USHORT
dtime['H'] = hours
new_offset, minutes = get_from_list(data_list, new_offset, 15) # USHORT
dtime['MN'] = minutes
new_offset, seconds = get_from_list(data_list, new_offset, 15) # USHORT
dtime['S'] = seconds
new_offset, milliseconds = get_from_list(data_list, new_offset, 16) # UNORM
dtime['MS'] = milliseconds
return new_offset, dtime
elif code == 23:
new_offset, O = get_from_list(data_list, start_offset, 22) # ORIGIN
new_offset, C = get_from_list(data_list, new_offset, 15) # USHORT
new_offset, I = get_from_list(data_list, new_offset, 19) # IDENT
return new_offset, (O, C, I)
# O = Origin Reference
# C = Copy Number
# I = Identifier
elif code == 24:
new_offset, T = get_from_list(data_list, start_offset, 19) # IDENT
new_offset, N = get_from_list(data_list, new_offset, 23) # OBNAME
objref = OrderedDict()
objref['T'] = T
objref['N'] = N
# T = obj type - N = obj name
return new_offset, objref
elif code == 25:
new_offset, T = get_from_list(data_list, start_offset, 19) # IDENT
new_offset, N = get_from_list(data_list, start_offset, 23) # OBNAME
new_offset, T = get_from_list(data_list, start_offset, 19) # IDENT
raise Exception()
# T = Object Type
# N = Object Name
# L = Attribute Label
elif code == 26:
new_offset, value = get_from_list(data_list, start_offset, 15) # USHORT
if value == 0:
return False
if value == 1:
return True
raise Exception()
elif code == 28:
v1 = ord(data_list[start_offset:start_offset+1])
result = bin(v1)[2:].zfill(8)
ret = []
for i in range(len(result)):
ret.append(int(result[i]))
return start_offset+1, ret
"""
0: Logical Record Structure
0 = Indirectly Formatted Logical Record
1 = Explicitly Formatted Logical Record
1: Predecessor
0 = This is the first segment of the Logical Record
1 = This is not the first segment of the Logical Record
2: Successor
0 = This is the last Segment of the Logical Record.
1 = This is not the last Segment of the Logical Record
3: Encryption
0 = No encryption.
1 = Logical Record is encrypted
4: Encryption Packet
0 = No Logical Record Segment Encryption Packet
1 = Logical Record Segment Encryption Packet is present
5: Checksum
0 = No checksum
1 = A checksum is present in the LRST
6: Trailing Length
0 = No Trailing Length
1 = A copy of the LRS lengt is present in the LRST
7: Padding
0 = No record padding
1 = Pad bytes are present in LRST
"""
"""
Given a Explicitly Formatted Logical Record (EFLR) code, returns its type,
description and allowed set types.
"""
'''
def get_EFLR_for_code(EFLR_code):
if not isinstance(EFLR_code, int):
raise Exception('EFLR_code must be a int value.')
if EFLR_code < 0 or EFLR_code > 127:
raise Exception('EFLR code does not exist.')
if EFLR_code > 11:
raise Exception('Undefined or reserved EFLR code are not available at this time.')
ret = {}
if EFLR_code == 0:
ret['type'] = 'FHLR'
ret['desc'] = 'File Header'
ret['allow'] = ['FILE-HEADER']
elif EFLR_code == 1:
ret['type'] = 'OLR'
ret['desc'] = 'Origin'
ret['allow'] = ['ORIGIN', 'WELL-REFERENCE']
elif EFLR_code == 2:
ret['type'] = 'AXIS'
ret['desc'] = 'Coordinate Axis'
ret['allow'] = ['AXIS']
elif EFLR_code == 3:
ret['type'] = 'CHANNL'
ret['desc'] = 'Channel-related information'
ret['allow'] = ['CHANNEL']
elif EFLR_code == 4:
ret['type'] = 'FRAME'
ret['desc'] = 'Frame Data'
ret['allow'] = ['FRAME', 'PATH']
elif EFLR_code == 5:
ret['type'] = 'STATIC'
ret['desc'] = 'Static Data'
ret['allow'] = ['CALIBRATION', 'CALIBRATION-COEFFICIENT', \
'CALIBRATION-MEASUREMENT', 'COMPUTATION', 'EQUIPMENT', 'GROUP',\
'PARAMETER', 'PROCESS', 'SPICE', 'TOOL', 'ZONE']
elif EFLR_code == 6:
ret['type'] = 'SCRIPT'
ret['desc'] = 'Textual Data'
ret['allow'] = ['COMMENT']
elif EFLR_code == 7:
ret['type'] = 'UPDATE'
ret['desc'] = 'Update Data'
ret['allow'] = ['UPDATE']
elif EFLR_code == 8:
ret['type'] = 'UDI'
ret['desc'] = 'Unformatted Data Identifier'
ret['allow'] = ['NO-FORMAT']
elif EFLR_code == 9:
ret['type'] = 'LNAME'
ret['desc'] = 'Long Name'
ret['allow'] = ['LONG-NAME']
elif EFLR_code == 10:
ret['type'] = 'SPEC'
ret['desc'] = 'Specificfation'
ret['allow'] = ['ATTRIBUTE', 'CODE', 'EFLR', 'IFLR', 'OBJECT-TYPE',\
'REPRESENTATION-CODE', 'SPECIFICATION', 'UNIT-SYMBOL']
elif EFLR_code == 11:
ret['type'] = 'DICT'
ret['desc'] = 'Dictionary'
ret['allow'] = ['BASE-DICTIONARY', 'IDENTIFIER', 'LEXICON', 'OPTION']
return ret
'''
def get_objname_from_tuple(obj_name_tuple):
"""Given a O, C, I tuple, return its string full name
(e.g 0&0&DEFINING_ORIGIN).
"""
O, C, I = obj_name_tuple
return str(O) + '&' + str(C) + '&' + I
def get_actual_objname(full_object_name):
"""Given a object string full name (e.g 0&0&DEFINING_ORIGIN), returns
its name (e.g DEFINING_ORIGIN).
"""
return full_object_name.split('&')[2]
class RepresentationCodes(object):
instance = None
def __init__(self):
# base_path == this floder
base_path = os.path.dirname(os.path.abspath(__file__))
rc_json_file = 'representation_codes.json'
self.codes = app.app_utils.read_json_file(
os.path.join(base_path, rc_json_file)
)
@classmethod
def start(cls):
if cls.instance is None:
cls.instance = RepresentationCodes()
@classmethod
def get_code(cls, code):
val = None
if cls.instance:
val = cls.instance.codes[code-1]
return val
class DLISObjectPool(object):
current_file_number = -1
current_lr = -1
lrs = None
objects = None
lr_to_object = None
object_to_lr = None
@classmethod
def init_pool(cls):
"""Init DLISObjectPool attributes.
"""
cls.current_file_number = -1
cls.current_lr = -1
cls.lrs = OrderedDict()
cls.objects = OrderedDict()
cls.lr_to_object = OrderedDict()
cls.object_to_lr = OrderedDict()
@classmethod
def register_logical_record(cls, lr_structure_type, lr_type, lr_code):
"""Register a new Logical Record, with its structure type, LR type,
LR code.
"""
if lr_structure_type != 0 and lr_structure_type != 1:
raise Exception('Logical Record Structure type invalid. ' +
'Valid types are 0 for IFLRs or 1 for EFLR.')
# Starting a new logical file
if lr_type == 'FILE-HEADER':
if cls.lrs is None:
cls.init_pool()
cls.current_file_number += 1
cls.lrs[cls.current_file_number] = OrderedDict()
cls.lr_to_object[cls.current_file_number] = OrderedDict()
cls.object_to_lr[cls.current_file_number] = OrderedDict()
cls.current_lr = 0
else:
cls.current_lr += 1
new_set = OrderedDict()
new_set['type'] = lr_type
new_set['code'] = lr_code
new_set['structure_type'] = lr_structure_type
new_set['template'] = []
new_set['closed'] = False
cls.lrs.get(cls.current_file_number)[cls.current_lr] = new_set
cls.lr_to_object.get(cls.current_file_number)[lr_type] = []
@classmethod
def register_object(cls, object_name):
"""Register a new DLIS Object, with its name.
"""
if not cls.get_logical_records()[-1].get('closed'):
cls.get_logical_records()[-1]['closed'] = True
if cls.objects.get(cls.current_file_number) is None:
cls.objects[cls.current_file_number] = OrderedDict()
cls.objects.get(cls.current_file_number)[object_name] = []
current_lr = cls.get_logical_records()[-1]
cls.object_to_lr.get(cls.current_file_number)[object_name] = current_lr.get('type')
cls.lr_to_object.get(cls.current_file_number).get(current_lr.get('type')).append(object_name)
@classmethod
def get_logical_records(cls, file_number=None):
if file_number is None:
file_number = cls.current_file_number
return list(cls.lrs.get(file_number).values())
@classmethod
def get_logical_record(cls, lr_type, file_number=None):
for lr in cls.get_logical_records(file_number):
if lr.get('type') == lr_type:
return lr
return None
@classmethod
def get_objects_of_type(cls, lr_type, file_number=None):
if file_number is None:
file_number = cls.current_file_number
obj_names = cls.lr_to_object.get(file_number).get(lr_type)
ret_map = OrderedDict()
if not obj_names:
return ret_map
for obj_name in obj_names:
ret_map[obj_name] = cls.objects.get(cls.current_file_number).get(obj_name)
return ret_map
@classmethod
def get_objects_dict_of_type(cls, lr_type, file_number=None):
if file_number is None:
file_number = cls.current_file_number
ret_map = OrderedDict()
objects = cls.get_objects_of_type(lr_type, file_number)
if not objects:
return ret_map
template_list = cls.get_logical_record(lr_type, file_number).get('template')
for obj_name, obj_values in objects.items():
obj_map = OrderedDict()
for idx, value in enumerate(obj_values):
#print 'idx', idx, template_list[idx]
obj_map[template_list[idx].get('name')] = value
ret_map[obj_name] = obj_map
return ret_map
@classmethod
def get_object_values_list(cls, object_name, file_number=None):
"""Given a object name (e.g 0&0&WN or 1&0&RHOB) return its values list.
If file_number is not given, the latest one will be used.
"""
if file_number is None:
file_number = cls.current_file_number
obj_values_list = cls.objects.get(file_number).get(object_name)
return obj_values_list
@classmethod
def get_object_values_dict(cls, object_name, file_number=None):
if file_number is None:
file_number = cls.current_file_number
obj_values_list = cls.get_object_values_list(object_name, file_number)
if obj_values_list is None:
return None
lr_type = cls.object_to_lr.get(file_number).get(object_name)
ret_map = OrderedDict()
for set_map in list(cls.lrs.get(file_number).values()):
if set_map.get('type') == lr_type:
for idx, template in enumerate(set_map.get('template')):
try:
ret_map[template.get('name')] = obj_values_list[idx]
except IndexError:
return ret_map
return ret_map
def _get_SUL(data):
# Getting Storage Unit Label (SUL)
if len(data) != 80 and len(data) != 128:
raise Exception('Input data size not according excepted (Excepted 80 or 120 bytes).')
SUL = OrderedDict()
SUL['Storage unit sequence number'] = data[0:4].decode("utf-8").strip()
SUL['RP66 version and format edition'] = data[4:9].decode("utf-8").strip()
SUL['Storage unit structure'] = data[9:15].decode("utf-8").strip()
if SUL.get('RP66 version and format edition').split('.')[0] == 'V1':
SUL['Maximum visible record length'] = data[15:20].decode("utf-8").strip()
SUL['Storage set identifier'] = data[20:80].decode("utf-8").strip()
elif SUL.get('RP66 version and format edition').split('.')[0] == 'V2':
if len(data) == 80:
raise Exception('DLIS version 2 needs 128 bytes for Storage Unit Label (SUL).')
SUL['Binding edition'] = data[15:19].decode("utf-8").strip()
SUL['Maximum visible record length'] = data[19:29].decode("utf-8").strip()
SUL['Producer organization code'] = data[29:39].decode("utf-8").strip()
SUL['Creation date'] = data[39:50].decode("utf-8").strip()
SUL['Serial number'] = data[50:62].decode("utf-8").strip()
SUL['reserved'] = data[62:68].decode("utf-8").strip()
SUL['Storage set identifier'] = data[68:128].decode("utf-8").strip()
return SUL
class DLISFile(object):
def __init__(self):
RepresentationCodes.start()
# base_path == this floder
base_path = os.path.dirname(os.path.abspath(__file__))
mapping_file = 'DLIS_RP66V1_MAPPING.json'
self.mapping = app.app_utils.read_json_file(
os.path.join(base_path, mapping_file)
)
#
self._clear()
def _clear(self):
#
DLISObjectPool.init_pool()
#
self.SUL = None
self.file_size = -1
self.data = None
self.data_props = None
#
self.file_header = None
self.origin = None
self.parameter = None
self.frame = None
self.channel = None
#
#self.queue = Queue()
#
def get_file_read_percent(self):
if self.file_size == -1:
return 0
return float(self.file.tell())*100/self.file_size
@staticmethod
def is_DLIS_file(filename):
try:
file_ = open(filename, mode='rb')
# Getting Storage Unit Label (SUL)
SUL = _get_SUL(file_.read(128))
file_.close()
if SUL.get('RP66 version and format edition').split('.')[0] != 'V1' \
and SUL.get('RP66 version and format edition').split('.')[0] != 'V2':
return False
return True
except Exception:
return False
def print_logical_file(self, file_index=None, limit=None):
if file_index is None:
file_index = range(len(self.data))
elif file_index == -1:
file_index = range(len(self.data)-1, len(self.data), 1)
elif file_index >= 0 and file_index < len(self.data):
file_index = range(file_index, file_index+1, 1)
else:
raise Exception()
if limit is not None:
counter = 1
for idx in file_index:
datum = self.data[idx]
print('\n\nLogical File:', idx)
for object_name, object_dict in datum.items():
print('\n', object_name)
for data_idx, data_values in object_dict.items():
print('\n ', data_idx)
for i, v in enumerate(data_values):
print(' ', list(self.data_props[idx].get(object_name).keys())[i], \
': ', v, list(self.data_props[idx].get(object_name).values())[i].get('UNITS'))
if limit is not None:
if counter == limit:
msg = '\nLimit of ' + str(limit) + ' registers was reached. End of print.'
print(msg)
return
else:
counter += 1
print('\nEnd of print.')
'''
def read(self, filename, callback=None, threading_stop_event=None):
#t = threading.Thread(target=self._read, args=(filename, callback))
#t.start()
#t.join()
p = Process(target=self._read, args=(filename, callback))
p.start()
p.join()
'''
def read(self, filename, callback=None, threading_stop_event=None):
# Clear DLISObjectPool
DLISObjectPool.init_pool()
#
self.filename = filename
#self.callback = callback
self.file = open(self.filename, mode='rb')
self.file_size = os.fstat(self.file.fileno()).st_size
# Getting Storage Unit Label (SUL)
self.SUL = _get_SUL(self.file.read(128))
# print()
# print(self.SUL)
# print()
if self.SUL.get('RP66 version and format edition').split('.')[0] == 'V1':
self.file.seek(80)
elif self.SUL.get('RP66 version and format edition').split('.')[0] != 'V2':
raise Exception('This is not a DLIS File.')
#
self._read_Logical_Records(callback, threading_stop_event)
#self._reading_process = Process(target=self._read_Logical_Records,
# args=(stop_event, 'task'))
#print 'a', self.file.tell()
#self._reading_process.start()
#print 'b', self.file.tell(), self._reading_process.is_alive()
#self._reading_process.join()
#print 'c', self.file.tell(), self._reading_process.is_alive()
#
self.file.close()
#
self._load_file_header_props()
self._load_origin_props()
self._load_parameter_props()
self._load_frame_props()
self._load_channel_props()
#
if threading_stop_event:
if threading_stop_event.is_set():
print('File reading canceled by user.')
else:
self.print_logical_file(-1, 1)
else:
self.print_logical_file(-1, 1)
#
print('\n\nself.data_props')
print(self.data_props)
# TODO: rever self._curves_info
self._curves_info = OrderedDict()
for item_od in self.data_props:
for curve_set_name in list(item_od.keys()):
curve_info_od = item_od[curve_set_name]
curve_set_name = get_actual_objname(curve_set_name)
self._curves_info[curve_set_name] = []
for curve_name, curve_props_od in curve_info_od.items():
curve_actual_name = get_actual_objname(curve_name)
curve_unit = curve_props_od['UNITS'].lower()
self._curves_info[curve_set_name].append(
(curve_actual_name, curve_unit)
)
#
print('\n\nself._curves_info')
print(self._curves_info)
#
# print('\n\nself.data')
# print(self.data)
#
# """
# TODO: rever self._curves_data
self._curves_data = OrderedDict()
for curve_set_name, curves_info_list in self._curves_info.items():
self._curves_data[curve_set_name] = []
for idx in range(len(curves_info_list)):
self._curves_data[curve_set_name].append([])
#
for item_od in self.data:
for iflr_descriptor in list(item_od.keys()):
curve_data_od = item_od[iflr_descriptor]
curve_set_name = get_actual_objname(iflr_descriptor)
for curves_data_list in list(curve_data_od.values()):
for idx, value in enumerate(curves_data_list):
# print('idx val:', idx, value)
self._curves_data[curve_set_name][idx].append(value)
#
for curves_data_list in list(self._curves_data.values()):
for idx in range(len(curves_data_list)):
curves_data_list[idx] = | np.asarray(curves_data_list[idx]) | numpy.asarray |
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon
import math
import matplotlib.ticker as plticker
from matplotlib import cm
from matplotlib.colors import LogNorm
from matplotlib import rc, rcParams
from scipy import interpolate
rc('text',usetex=True)
rc('font',**{'family':'serif','serif':['DejaVu Serif Display']})
plt.rcParams.update({'font.size': 20})
colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
r0 = 12.
z0 = 1.*r0+2.
rho = 0.15
gamma_0 = 1.09
zmax = 1.e8
gamma_acc = np.array([4,8,18])
z_acc = np.array([1e3,1e4,1e5])
sigma_f = np.array([1.,0.5,0.1])
sigma_0_1 = (1.+sigma_f[0])*gamma_acc[0]/gamma_0-1.
sigma_0_2 = (1.+sigma_f[1])*gamma_acc[1]/gamma_0-1.
sigma_0_3 = (1.+sigma_f[2])*gamma_acc[2]/gamma_0-1.
z_1 = np.logspace(0,np.log10(z_acc[0]),30)
z_2 = np.logspace(0,np.log10(z_acc[1]),40)
z_3 = np.logspace(0,np.log10(z_acc[2]),50)
z_1_post = np.logspace(np.log10(z_acc[0]),np.log10(zmax),70)
z_2_post = np.logspace(np.log10(z_acc[1]),np.log10(zmax),60)
z_3_post = np.logspace(np.log10(z_acc[2]),np.log10(zmax),50)
gamma_1 = gamma_0 + (gamma_acc[0]-gamma_0)*(z_1**(1./2.)-z0**(1./2.))/(z_acc[0]**(1./2.)-z0**(1./2.))
gamma_2 = gamma_0 + (gamma_acc[1]-gamma_0)*(z_2**(1./2.)-z0**(1./2.))/(z_acc[1]**(1./2.)-z0**(1./2.))
gamma_3 = gamma_0 + (gamma_acc[2]-gamma_0)*(z_3**(1./2.)-z0**(1./2.))/(z_acc[2]**(1./2.)-z0**(1./2.))
gamma_1_post = np.zeros(70)+gamma_acc[0]
gamma_2_post = np.zeros(60)+gamma_acc[1]
gamma_3_post = np.zeros(50)+gamma_acc[2]
sigma_1 = (gamma_0/gamma_1)*(1.+sigma_0_1)-1.
sigma_2 = (gamma_0/gamma_2)*(1.+sigma_0_2)-1.
sigma_3 = (gamma_0/gamma_3)*(1.+sigma_0_3)-1.
sigma_1_post = np.zeros(70)+sigma_f[0]
sigma_2_post = np.zeros(60)+sigma_f[1]
sigma_3_post = np.zeros(50)+sigma_f[2]
theta_1 = rho/gamma_1
theta_2 = rho/gamma_2
theta_3 = rho/gamma_3
r_1 = r0 + (z_1-z0)*np.tan(theta_1)
r_2 = r0 + (z_2-z0)*np.tan(theta_2)
r_3 = r0 + (z_3-z0)*np.tan(theta_3)
r_1_post = r_1[29] + (z_1_post-z_acc[0])*np.tan(rho/gamma_acc[0])
r_2_post = r_2[39] + (z_2_post-z_acc[1])* | np.tan(rho/gamma_acc[1]) | numpy.tan |
import warnings
import numpy as np
import pandas as pd
import cvxpy as cp
import pytest
import scipy.optimize as sco
from pypfopt import EfficientFrontier
from pypfopt import risk_models
from pypfopt import objective_functions
from pypfopt import exceptions
from tests.utilities_for_tests import get_data, setup_efficient_frontier
def test_data_source():
df = get_data()
assert isinstance(df, pd.DataFrame)
assert df.shape[1] == 20
assert len(df) == 7126
assert df.index.is_all_dates
def test_returns_dataframe():
df = get_data()
returns_df = df.pct_change().dropna(how="all")
assert isinstance(returns_df, pd.DataFrame)
assert returns_df.shape[1] == 20
assert len(returns_df) == 7125
assert returns_df.index.is_all_dates
assert not ((returns_df > 1) & returns_df.notnull()).any().any()
def test_efficient_frontier_inheritance():
ef = setup_efficient_frontier()
assert ef.clean_weights
assert ef.n_assets
assert ef.tickers
assert isinstance(ef._constraints, list)
assert isinstance(ef._lower_bounds, np.ndarray)
assert isinstance(ef._upper_bounds, np.ndarray)
def test_portfolio_performance():
ef = setup_efficient_frontier()
with pytest.raises(ValueError):
ef.portfolio_performance()
ef.min_volatility()
perf = ef.portfolio_performance()
assert isinstance(perf, tuple)
assert len(perf) == 3
assert isinstance(perf[0], float)
def test_min_volatility():
ef = setup_efficient_frontier()
w = ef.min_volatility()
assert isinstance(w, dict)
assert set(w.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
assert all([i >= 0 for i in w.values()])
np.testing.assert_allclose(
ef.portfolio_performance(),
(0.17931232481259154, 0.15915084514118694, 1.00101463282373),
)
def test_min_volatility_different_solver():
ef = setup_efficient_frontier()
ef.solver = "ECOS"
w = ef.min_volatility()
assert isinstance(w, dict)
assert set(w.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
assert all([i >= 0 for i in w.values()])
test_performance = (0.179312, 0.159151, 1.001015)
np.testing.assert_allclose(ef.portfolio_performance(), test_performance, atol=1e-5)
ef = setup_efficient_frontier()
ef.solver = "OSQP"
w = ef.min_volatility()
np.testing.assert_allclose(ef.portfolio_performance(), test_performance, atol=1e-5)
ef = setup_efficient_frontier()
ef.solver = "SCS"
w = ef.min_volatility()
np.testing.assert_allclose(ef.portfolio_performance(), test_performance, atol=1e-3)
def test_min_volatility_no_rets():
# Should work with no rets, see issue #82
df = get_data()
S = risk_models.sample_cov(df)
ef = EfficientFrontier(None, S)
w = ef.min_volatility()
assert isinstance(w, dict)
assert set(w.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
assert all([i >= 0 for i in w.values()])
np.testing.assert_almost_equal(ef.portfolio_performance()[1], 0.15915084514118694)
def test_min_volatility_tx_costs():
# Baseline
ef = setup_efficient_frontier()
ef.min_volatility()
w1 = ef.weights
# Pretend we were initally equal weight
ef = setup_efficient_frontier()
prev_w = np.array([1 / ef.n_assets] * ef.n_assets)
ef.add_objective(objective_functions.transaction_cost, w_prev=prev_w)
ef.min_volatility()
w2 = ef.weights
# TX cost should pull closer to prev portfolio
assert np.abs(prev_w - w2).sum() < np.abs(prev_w - w1).sum()
def test_min_volatility_short():
ef = EfficientFrontier(
*setup_efficient_frontier(data_only=True), weight_bounds=(None, None)
)
w = ef.min_volatility()
assert isinstance(w, dict)
assert set(w.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
np.testing.assert_allclose(
ef.portfolio_performance(),
(0.1721356467349655, 0.1555915367269669, 0.9777887019776287),
)
# Shorting should reduce volatility
volatility = ef.portfolio_performance()[1]
ef_long_only = setup_efficient_frontier()
ef_long_only.min_volatility()
long_only_volatility = ef_long_only.portfolio_performance()[1]
assert volatility < long_only_volatility
def test_min_volatility_L2_reg():
ef = setup_efficient_frontier()
ef.add_objective(objective_functions.L2_reg, gamma=1)
weights = ef.min_volatility()
assert isinstance(weights, dict)
assert set(weights.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
assert all([i >= 0 for i in weights.values()])
ef2 = setup_efficient_frontier()
ef2.min_volatility()
# L2_reg should pull close to equal weight
equal_weight = np.full((ef.n_assets,), 1 / ef.n_assets)
assert (
np.abs(equal_weight - ef.weights).sum()
< np.abs(equal_weight - ef2.weights).sum()
)
np.testing.assert_allclose(
ef.portfolio_performance(),
(0.23129890623344232, 0.1955254118258614, 1.080672349748733),
)
def test_min_volatility_L2_reg_many_values():
ef = setup_efficient_frontier()
ef.min_volatility()
# Count the number of weights more 1%
initial_number = sum(ef.weights > 0.01)
for _ in range(10):
ef.add_objective(objective_functions.L2_reg, gamma=0.05)
ef.min_volatility()
np.testing.assert_almost_equal(ef.weights.sum(), 1)
new_number = sum(ef.weights > 0.01)
# Higher gamma should reduce the number of small weights
assert new_number >= initial_number
initial_number = new_number
def test_min_volatility_L2_reg_limit_case():
ef = setup_efficient_frontier()
ef.add_objective(objective_functions.L2_reg, gamma=1e10)
ef.min_volatility()
equal_weights = np.array([1 / ef.n_assets] * ef.n_assets)
np.testing.assert_array_almost_equal(ef.weights, equal_weights)
def test_min_volatility_L2_reg_increases_vol():
# L2 reg should reduce the number of small weights
# but increase in-sample volatility.
ef_no_reg = setup_efficient_frontier()
ef_no_reg.min_volatility()
vol_no_reg = ef_no_reg.portfolio_performance()[1]
ef = setup_efficient_frontier()
ef.add_objective(objective_functions.L2_reg, gamma=2)
ef.min_volatility()
vol = ef.portfolio_performance()[1]
assert vol > vol_no_reg
def test_min_volatility_tx_costs_L2_reg():
ef = setup_efficient_frontier()
prev_w = np.array([1 / ef.n_assets] * ef.n_assets)
ef.add_objective(objective_functions.transaction_cost, w_prev=prev_w)
ef.add_objective(objective_functions.L2_reg)
ef.min_volatility()
np.testing.assert_allclose(
ef.portfolio_performance(),
(0.2316565265271545, 0.1959773703677164, 1.0800049318450338),
)
def test_min_volatility_cvxpy_vs_scipy():
# cvxpy
ef = setup_efficient_frontier()
ef.min_volatility()
w1 = ef.weights
# scipy
args = (ef.cov_matrix,)
initial_guess = np.array([1 / ef.n_assets] * ef.n_assets)
result = sco.minimize(
objective_functions.portfolio_variance,
x0=initial_guess,
args=args,
method="SLSQP",
bounds=[(0, 1)] * 20,
constraints=[{"type": "eq", "fun": lambda x: np.sum(x) - 1}],
)
w2 = result["x"]
cvxpy_var = objective_functions.portfolio_variance(w1, ef.cov_matrix)
scipy_var = objective_functions.portfolio_variance(w2, ef.cov_matrix)
assert cvxpy_var <= scipy_var
def test_min_volatility_sector_constraints():
sector_mapper = {
"T": "auto",
"UAA": "airline",
"SHLD": "retail",
"XOM": "energy",
"RRC": "energy",
"BBY": "retail",
"MA": "fig",
"PFE": "pharma",
"JPM": "fig",
"SBUX": "retail",
"GOOG": "tech",
"AAPL": "tech",
"FB": "tech",
"AMZN": "tech",
"BABA": "tech",
"GE": "utility",
"AMD": "tech",
"WMT": "retail",
"BAC": "fig",
"GM": "auto",
}
sector_upper = {
"tech": 0.2,
"utility": 0.1,
"retail": 0.2,
"fig": 0.4,
"airline": 0.05,
"energy": 0.2,
}
sector_lower = {"utility": 0.01, "fig": 0.02, "airline": 0.01}
# ef = setup_efficient_frontier()
ef = EfficientFrontier(
*setup_efficient_frontier(data_only=True), weight_bounds=(None, None)
)
ef.add_sector_constraints(sector_mapper, sector_lower, sector_upper)
weights = ef.min_volatility()
for sector in list(set().union(sector_upper, sector_lower)):
sector_sum = 0
for t, v in weights.items():
if sector_mapper[t] == sector:
sector_sum += v
assert sector_sum <= sector_upper.get(sector, 1) + 1e-5
assert sector_sum >= sector_lower.get(sector, 0) - 1e-5
def test_min_volatility_vs_max_sharpe():
# Test based on issue #75
expected_returns_daily = pd.Series(
[0.043622, 0.120588, 0.072331, 0.056586], index=["AGG", "SPY", "GLD", "HYG"]
)
covariance_matrix = pd.DataFrame(
[
[0.000859, -0.000941, 0.001494, -0.000062],
[-0.000941, 0.022400, -0.002184, 0.005747],
[0.001494, -0.002184, 0.011518, -0.000129],
[-0.000062, 0.005747, -0.000129, 0.002287],
],
index=["AGG", "SPY", "GLD", "HYG"],
columns=["AGG", "SPY", "GLD", "HYG"],
)
ef = EfficientFrontier(expected_returns_daily, covariance_matrix)
ef.min_volatility()
vol_min_vol = ef.portfolio_performance(risk_free_rate=0.00)[1]
ef = EfficientFrontier(expected_returns_daily, covariance_matrix)
ef.max_sharpe(risk_free_rate=0.00)
vol_max_sharpe = ef.portfolio_performance(risk_free_rate=0.00)[1]
assert vol_min_vol < vol_max_sharpe
def test_min_volatility_nonconvex_objective():
ef = setup_efficient_frontier()
ef.add_objective(lambda x: cp.sum((x + 1) / (x + 2) ** 2))
with pytest.raises(exceptions.OptimizationError):
ef.min_volatility()
def test_min_volatility_nonlinear_constraint():
ef = setup_efficient_frontier()
ef.add_constraint(lambda x: (x + 1) / (x + 2) ** 2 <= 0.5)
with pytest.raises(exceptions.OptimizationError):
ef.min_volatility()
def test_max_sharpe_long_only():
ef = setup_efficient_frontier()
w = ef.max_sharpe()
assert isinstance(w, dict)
assert set(w.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
assert all([i >= 0 for i in w.values()])
np.testing.assert_allclose(
ef.portfolio_performance(),
(0.33035037367760506, 0.21671276571944567, 1.4320816434015786),
)
def test_max_sharpe_long_weight_bounds():
ef = EfficientFrontier(
*setup_efficient_frontier(data_only=True), weight_bounds=(0.03, 0.13)
)
ef.max_sharpe()
np.testing.assert_almost_equal(ef.weights.sum(), 1)
assert ef.weights.min() >= 0.03
assert ef.weights.max() <= 0.13
bounds = [(0.01, 0.13), (0.02, 0.11)] * 10
ef = EfficientFrontier(
*setup_efficient_frontier(data_only=True), weight_bounds=bounds
)
ef.max_sharpe()
assert (0.01 <= ef.weights[::2]).all() and (ef.weights[::2] <= 0.13).all()
assert (0.02 <= ef.weights[1::2]).all() and (ef.weights[1::2] <= 0.11).all()
def test_max_sharpe_explicit_bound():
ef = setup_efficient_frontier()
ef.add_constraint(lambda w: w[0] >= 0.2)
ef.add_constraint(lambda w: w[2] == 0.15)
ef.add_constraint(lambda w: w[3] + w[4] <= 0.10)
ef.max_sharpe()
np.testing.assert_almost_equal(ef.weights.sum(), 1)
assert ef.weights[0] >= 0.2 - 1e-5
np.testing.assert_almost_equal(ef.weights[2], 0.15)
assert ef.weights[3] + ef.weights[4] <= 0.10 + 1e-5
def test_max_sharpe_short():
ef = EfficientFrontier(
*setup_efficient_frontier(data_only=True), weight_bounds=(None, None)
)
w = ef.max_sharpe()
assert isinstance(w, dict)
assert set(w.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
np.testing.assert_allclose(
ef.portfolio_performance(),
(0.4072439477276246, 0.24823487545231313, 1.5599900981762558),
)
sharpe = ef.portfolio_performance()[2]
ef_long_only = setup_efficient_frontier()
ef_long_only.max_sharpe()
long_only_sharpe = ef_long_only.portfolio_performance()[2]
assert sharpe > long_only_sharpe
def test_max_sharpe_L2_reg():
ef = setup_efficient_frontier()
ef.add_objective(objective_functions.L2_reg, gamma=5)
with warnings.catch_warnings(record=True) as w:
weights = ef.max_sharpe()
assert len(w) == 1
assert isinstance(weights, dict)
assert set(weights.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
assert all([i >= 0 for i in weights.values()])
np.testing.assert_allclose(
ef.portfolio_performance(),
(0.2936875354933478, 0.22783545277575057, 1.2012508683744123),
)
ef2 = setup_efficient_frontier()
ef2.max_sharpe()
# L2_reg should pull close to equal weight
equal_weight = np.full((ef.n_assets,), 1 / ef.n_assets)
assert (
np.abs(equal_weight - ef.weights).sum()
< np.abs(equal_weight - ef2.weights).sum()
)
def test_max_sharpe_L2_reg_many_values():
warnings.filterwarnings("ignore")
ef = setup_efficient_frontier()
ef.max_sharpe()
# Count the number of weights more 1%
initial_number = sum(ef.weights > 0.01)
for i in range(1, 20, 2):
ef = setup_efficient_frontier()
ef.add_objective(objective_functions.L2_reg, gamma=0.05 * i)
ef.max_sharpe()
np.testing.assert_almost_equal(ef.weights.sum(), 1)
new_number = sum(ef.weights > 0.01)
# Higher gamma should reduce the number of small weights
assert new_number >= initial_number
initial_number = new_number
def test_max_sharpe_L2_reg_different_gamma():
ef = setup_efficient_frontier()
ef.add_objective(objective_functions.L2_reg, gamma=1)
ef.max_sharpe()
ef2 = setup_efficient_frontier()
ef2.add_objective(objective_functions.L2_reg, gamma=0.01)
ef2.max_sharpe()
# Higher gamma should pull close to equal weight
equal_weight = np.array([1 / ef.n_assets] * ef.n_assets)
assert (
np.abs(equal_weight - ef.weights).sum()
< np.abs(equal_weight - ef2.weights).sum()
)
def test_max_sharpe_L2_reg_reduces_sharpe():
# L2 reg should reduce the number of small weights at the cost of Sharpe
ef_no_reg = setup_efficient_frontier()
ef_no_reg.max_sharpe()
sharpe_no_reg = ef_no_reg.portfolio_performance()[2]
ef = setup_efficient_frontier()
ef.add_objective(objective_functions.L2_reg, gamma=2)
ef.max_sharpe()
sharpe = ef.portfolio_performance()[2]
assert sharpe < sharpe_no_reg
def test_max_sharpe_L2_reg_with_shorts():
ef_no_reg = setup_efficient_frontier()
ef_no_reg.max_sharpe()
initial_number = sum(ef_no_reg.weights > 0.01)
ef = EfficientFrontier(
*setup_efficient_frontier(data_only=True), weight_bounds=(None, None)
)
ef.add_objective(objective_functions.L2_reg)
w = ef.max_sharpe()
assert isinstance(w, dict)
assert set(w.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
np.testing.assert_allclose(
ef.portfolio_performance(),
(0.3076093180094401, 0.22415982749409985, 1.2830546901496447),
)
new_number = sum(ef.weights > 0.01)
assert new_number >= initial_number
def test_max_sharpe_risk_free_rate():
ef = setup_efficient_frontier()
ef.max_sharpe()
_, _, initial_sharpe = ef.portfolio_performance()
ef = setup_efficient_frontier()
ef.max_sharpe(risk_free_rate=0.10)
_, _, new_sharpe = ef.portfolio_performance(risk_free_rate=0.10)
assert new_sharpe <= initial_sharpe
ef = setup_efficient_frontier()
ef.max_sharpe(risk_free_rate=0)
_, _, new_sharpe = ef.portfolio_performance(risk_free_rate=0)
assert new_sharpe >= initial_sharpe
def test_min_vol_pair_constraint():
ef = setup_efficient_frontier()
ef.min_volatility()
old_sum = ef.weights[:2].sum()
ef = setup_efficient_frontier()
ef.add_constraint(lambda w: (w[1] + w[0] <= old_sum / 2))
ef.min_volatility()
new_sum = ef.weights[:2].sum()
assert new_sum <= old_sum / 2 + 1e-4
def test_max_sharpe_pair_constraint():
ef = setup_efficient_frontier()
ef.max_sharpe()
old_sum = ef.weights[:2].sum()
ef = setup_efficient_frontier()
ef.add_constraint(lambda w: (w[1] + w[0] <= old_sum / 2))
ef.max_sharpe()
new_sum = ef.weights[:2].sum()
assert new_sum <= old_sum / 2 + 1e-4
def test_max_sharpe_sector_constraints_manual():
sector_mapper = {
"GOOG": "tech",
"AAPL": "tech",
"FB": "tech",
"AMZN": "tech",
"BABA": "tech",
"GE": "utility",
"AMD": "tech",
"WMT": "retail",
"BAC": "fig",
"GM": "auto",
"T": "auto",
"UAA": "airline",
"SHLD": "retail",
"XOM": "energy",
"RRC": "energy",
"BBY": "retail",
"MA": "fig",
"PFE": "pharma",
"JPM": "fig",
"SBUX": "retail",
}
sector_upper = {
"tech": 0.2,
"utility": 0.1,
"retail": 0.2,
"fig": 0.4,
"airline": 0.05,
"energy": 0.2,
}
sector_lower = {"utility": 0.01, "fig": 0.02, "airline": 0.01}
ef = setup_efficient_frontier()
for sector in sector_upper:
is_sector = [sector_mapper[t] == sector for t in ef.tickers]
ef.add_constraint(lambda w: cp.sum(w[is_sector]) <= sector_upper[sector])
for sector in sector_lower:
is_sector = [sector_mapper[t] == sector for t in ef.tickers]
ef.add_constraint(lambda w: cp.sum(w[is_sector]) >= sector_lower[sector])
weights = ef.max_sharpe()
for sector in list(set().union(sector_upper, sector_lower)):
sector_sum = 0
for t, v in weights.items():
if sector_mapper[t] == sector:
sector_sum += v
assert sector_sum <= sector_upper.get(sector, 1) + 1e-5
assert sector_sum >= sector_lower.get(sector, 0) - 1e-5
def test_max_sharpe_sector_constraints_auto():
sector_mapper = {
"GOOG": "tech",
"AAPL": "tech",
"FB": "tech",
"AMZN": "tech",
"BABA": "tech",
"GE": "utility",
"AMD": "tech",
"WMT": "retail",
"BAC": "fig",
"GM": "auto",
"T": "auto",
"UAA": "airline",
"SHLD": "retail",
"XOM": "energy",
"RRC": "energy",
"BBY": "retail",
"MA": "fig",
"PFE": "pharma",
"JPM": "fig",
"SBUX": "retail",
}
sector_upper = {
"tech": 0.2,
"utility": 0.1,
"retail": 0.2,
"fig": 0.4,
"airline": 0.05,
"energy": 0.2,
}
sector_lower = {"utility": 0.01, "fig": 0.02, "airline": 0.01}
ef = setup_efficient_frontier()
ef.add_sector_constraints(sector_mapper, sector_lower, sector_upper)
weights = ef.max_sharpe()
for sector in list(set().union(sector_upper, sector_lower)):
sector_sum = 0
for t, v in weights.items():
if sector_mapper[t] == sector:
sector_sum += v
assert sector_sum <= sector_upper.get(sector, 1) + 1e-5
assert sector_sum >= sector_lower.get(sector, 0) - 1e-5
def test_efficient_risk_sector_constraints_manual():
sector_mapper = {
"GOOG": "tech",
"AAPL": "tech",
"FB": "tech",
"AMZN": "tech",
"BABA": "tech",
"GE": "utility",
"AMD": "tech",
"WMT": "retail",
"BAC": "fig",
"GM": "auto",
"T": "auto",
"UAA": "airline",
"SHLD": "retail",
"XOM": "energy",
"RRC": "energy",
"BBY": "retail",
"MA": "fig",
"PFE": "pharma",
"JPM": "fig",
"SBUX": "retail",
}
sector_upper = {
"tech": 0.2,
"utility": 0.1,
"retail": 0.2,
"fig": 0.4,
"airline": 0.05,
"energy": 0.2,
}
sector_lower = {"utility": 0.01, "fig": 0.02, "airline": 0.01}
ef = setup_efficient_frontier()
for sector in sector_upper:
is_sector = [sector_mapper[t] == sector for t in ef.tickers]
ef.add_constraint(lambda w: cp.sum(w[is_sector]) <= sector_upper[sector])
for sector in sector_lower:
is_sector = [sector_mapper[t] == sector for t in ef.tickers]
ef.add_constraint(lambda w: cp.sum(w[is_sector]) >= sector_lower[sector])
weights = ef.efficient_risk(0.19)
for sector in list(set().union(sector_upper, sector_lower)):
sector_sum = 0
for t, v in weights.items():
if sector_mapper[t] == sector:
sector_sum += v
assert sector_sum <= sector_upper.get(sector, 1) + 1e-5
assert sector_sum >= sector_lower.get(sector, 0) - 1e-5
def test_efficient_risk_sector_constraints_auto():
sector_mapper = {
"GOOG": "tech",
"AAPL": "tech",
"FB": "tech",
"AMZN": "tech",
"BABA": "tech",
"GE": "utility",
"AMD": "tech",
"WMT": "retail",
"BAC": "fig",
"GM": "auto",
"T": "auto",
"UAA": "airline",
"SHLD": "retail",
"XOM": "energy",
"RRC": "energy",
"BBY": "retail",
"MA": "fig",
"PFE": "pharma",
"JPM": "fig",
"SBUX": "retail",
}
sector_upper = {
"tech": 0.2,
"utility": 0.1,
"retail": 0.2,
"fig": 0.4,
"airline": 0.05,
"energy": 0.2,
}
sector_lower = {"utility": 0.01, "fig": 0.02, "airline": 0.01}
ef = setup_efficient_frontier()
ef.add_sector_constraints(sector_mapper, sector_lower, sector_upper)
weights = ef.efficient_risk(0.19)
for sector in list(set().union(sector_upper, sector_lower)):
sector_sum = 0
for t, v in weights.items():
if sector_mapper[t] == sector:
sector_sum += v
assert sector_sum <= sector_upper.get(sector, 1) + 1e-5
assert sector_sum >= sector_lower.get(sector, 0) - 1e-5
def test_max_quadratic_utility():
ef = setup_efficient_frontier()
w = ef.max_quadratic_utility(risk_aversion=2)
assert isinstance(w, dict)
assert set(w.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
np.testing.assert_allclose(
ef.portfolio_performance(),
(0.40064324249527605, 0.2917825266124642, 1.3045443362029479),
)
ret1, var1, _ = ef.portfolio_performance()
# increasing risk_aversion should lower both vol and return
ef.max_quadratic_utility(10)
ret2, var2, _ = ef.portfolio_performance()
assert ret2 < ret1 and var2 < var1
def test_max_quadratic_utility_with_shorts():
ef = EfficientFrontier(
*setup_efficient_frontier(data_only=True), weight_bounds=(-1, 1)
)
ef.max_quadratic_utility()
np.testing.assert_almost_equal(ef.weights.sum(), 1)
np.testing.assert_allclose(
ef.portfolio_performance(),
(1.3318330413711252, 1.0198436183533854, 1.2863080356272452),
)
def test_max_quadratic_utility_market_neutral():
ef = EfficientFrontier(
*setup_efficient_frontier(data_only=True), weight_bounds=(-1, 1)
)
ef.max_quadratic_utility(market_neutral=True)
np.testing.assert_almost_equal(ef.weights.sum(), 0)
np.testing.assert_allclose(
ef.portfolio_performance(),
(1.13434841843883, 0.9896404148973286, 1.1260134506071473),
)
def test_max_quadratic_utility_limit():
# in limit of large risk_aversion, this should approach min variance.
ef = setup_efficient_frontier()
ef.max_quadratic_utility(risk_aversion=1e10)
ef2 = setup_efficient_frontier()
ef2.min_volatility()
np.testing.assert_array_almost_equal(ef.weights, ef2.weights)
def test_max_quadratic_utility_L2_reg():
ef = setup_efficient_frontier()
ef.add_objective(objective_functions.L2_reg, gamma=5)
weights = ef.max_quadratic_utility()
assert isinstance(weights, dict)
assert set(weights.keys()) == set(ef.tickers)
np.testing.assert_almost_equal(ef.weights.sum(), 1)
assert all([i >= 0 for i in weights.values()])
np.testing.assert_allclose(
ef.portfolio_performance(),
(0.2602803268728476, 0.21603540587515674, 1.112226608872166),
)
ef2 = setup_efficient_frontier()
ef2.max_quadratic_utility()
# L2_reg should pull close to equal weight
equal_weight = np.full((ef.n_assets,), 1 / ef.n_assets)
assert (
np.abs(equal_weight - ef.weights).sum()
< | np.abs(equal_weight - ef2.weights) | numpy.abs |
"""
Plotting function
"""
from create_geometry import BladeGeometry
from lifting_line_solver import LiftingLineSolver
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from read_BEMdata_into_Python import read_matlab_data
import numpy as np
phase_shifts = np.linspace(0, 180, 4)
colors = ["lawngreen", "deepskyblue", "orangered", "darkviolet"]
# start plots
fig_rotor, ax_rotor = plt.subplots(1, 1, dpi=150)
nspan = 20
ntheta = 200
nblades = 3
spacing = 'equal'
nrotor = 2
first_blades_right = []
first_blade_left = []
for color, phase_shift in zip(colors, phase_shifts):
prop_geo = BladeGeometry(radius=50.0, tsr=8, v_inf=10.0, n_blades=3, n_span=nspan, phase_diff=phase_shift,
double_rotor=True,
n_theta=ntheta, spacing=spacing, a=0.33, xshift=0, yshift=100, zshift=0)
blade = prop_geo.bladepanels
theta = | np.linspace(0, 2 * np.pi) | numpy.linspace |
import json
import pytest
from lxml import etree
import numpy as np
import xarray as xr
import pandas as pd
import finch
import finch.processes
from finch.processes.wps_xclim_indices import XclimIndicatorBase
from finch.processes.wps_base import make_xclim_indicator_process
from . utils import execute_process, wps_input_file, wps_literal_input
from pathlib import Path
from pywps.app.exceptions import ProcessError
from pywps import configuration
from unittest import mock
from numpy.testing import assert_equal
from xclim.testing import open_dataset
K2C = 273.16
configuration.CONFIG['finch:metadata']['testing_session'] = "True"
def _get_output_standard_name(process_identifier):
for p in finch.processes.get_processes():
if p.identifier == process_identifier:
return p.xci.standard_name
@pytest.mark.parametrize("indicator", finch.processes.indicators)
def test_indicators_processes_discovery(indicator):
process = make_xclim_indicator_process(indicator, "Process", XclimIndicatorBase)
assert indicator.identifier == process.identifier
# Remove args not supported by finch: we remove special kinds,
# 50 is "kwargs". 70 is Dataset ('ds') and 99 is "unknown". All normal types are 0-9.
parameters = set([k for k, v in indicator.parameters.items() if v['kind'] < 50 or k == 'indexer'])
parameters.add("check_missing")
parameters.add("missing_options")
parameters.add("cf_compliance")
parameters.add("data_validation")
parameters.add("variable")
if "indexer" in parameters:
parameters.remove("indexer")
parameters.add("month")
parameters.add("season")
assert_equal(parameters, set(i.identifier for i in process.inputs), indicator.identifier)
# TODO : Extend test coverage
def test_processes(client, netcdf_datasets):
"""Run a dummy calculation for every process, keeping some default parameters."""
# indicators = finch.processes.indicators
processes = filter(lambda x: isinstance(x, XclimIndicatorBase), finch.processes.xclim.__dict__.values())
literal_inputs = {
"freq": "MS",
"window": "3",
"mid_date": "07-01",
"before_date": "07-01",
}
keep_defaults = ["thresh", "thresh_tasmin", "thresh_tasmax"]
attrs = xr.open_dataset(list(netcdf_datasets.values())[0], decode_times=False).attrs
for process in processes:
inputs = []
for process_input in process.inputs:
name = process_input.identifier
if name in netcdf_datasets.keys():
inputs.append(wps_input_file(name, netcdf_datasets[name]))
elif name in literal_inputs.keys():
inputs.append(wps_literal_input(name, literal_inputs[name]))
elif name in keep_defaults:
pass
else:
raise NotImplementedError
outputs = execute_process(client, process.identifier, inputs)
ds = xr.open_dataset(outputs[0])
output_variable = list(ds.data_vars)[0]
assert getattr(ds, output_variable).standard_name == process.xci.standard_name
assert ds.attrs['testing_session']
model = attrs["driving_model_id"]
experiment = attrs["driving_experiment_id"].replace(",", "+")
ensemble = (
f"r{attrs['driving_realization']}"
f"i{attrs['driving_initialization_method']}"
f"p{attrs['driving_physics_version']}"
)
date_start = pd.to_datetime(str(ds.time[0].values))
date_end = pd.to_datetime(str(ds.time[-1].values))
expected = (
f"{output_variable.replace('_', '-')}_"
f"{model}_{experiment}_{ensemble}_"
f"{date_start:%Y%m%d}-{date_end:%Y%m%d}.nc"
)
assert Path(outputs[0]).name == expected
def test_wps_daily_temperature_range_multiple(client, netcdf_datasets):
identifier = "dtr"
inputs = [wps_literal_input("freq", "YS")]
for _ in range(5):
inputs.append(wps_input_file("tasmax", netcdf_datasets["tasmax"]))
inputs.append(wps_input_file("tasmin", netcdf_datasets["tasmin"]))
with mock.patch(
"finch.processes.wps_xclim_indices.FinchProgressBar"
) as mock_progress:
outputs = execute_process(
client, identifier, inputs, output_names=["output_netcdf", "ref"]
)
assert mock_progress.call_args_list[0][1]["start_percentage"] == 0
assert mock_progress.call_args_list[0][1]["end_percentage"] == 20
assert mock_progress.call_args_list[4][1]["start_percentage"] == 80
assert mock_progress.call_args_list[4][1]["end_percentage"] == 100
et = etree.fromstring(outputs[1].data[0].encode())
urls = [e[2].text for e in et if e.tag.endswith("file")]
assert len(urls) == 5, "Containing 10 files"
assert len(set(urls)) == 5, "With different links"
assert urls[1].endswith("-1.nc")
def test_wps_daily_temperature_range_multiple_not_same_length(client, netcdf_datasets):
identifier = "dtr"
inputs = [wps_literal_input("freq", "YS")]
for _ in range(5):
inputs.append(wps_input_file("tasmax", netcdf_datasets["tasmax"]))
inputs.append(wps_input_file("tasmin", netcdf_datasets["tasmin"]))
inputs.pop()
with pytest.raises(ProcessError, match="must be equal"):
execute_process(
client, identifier, inputs, output_names=["output_netcdf", "ref"]
)
def test_heat_wave_frequency_window_thresh_parameters(client, netcdf_datasets):
identifier = "heat_wave_frequency"
inputs = [
wps_input_file("tasmax", netcdf_datasets["tasmax"]),
wps_input_file("tasmin", netcdf_datasets["tasmin"]),
wps_literal_input("window", "3"),
wps_literal_input("freq", "YS"),
wps_literal_input("thresh_tasmin", "20 degC"),
wps_literal_input("thresh_tasmax", "25 degC"),
]
outputs = execute_process(client, identifier, inputs)
ds = xr.open_dataset(outputs[0])
assert ds.attrs["frequency"] == "yr"
assert ds.heat_wave_frequency.standard_name == _get_output_standard_name(identifier)
def test_heat_wave_index_thresh_parameter(client, netcdf_datasets):
identifier = "heat_wave_index"
inputs = [
wps_input_file("tasmax", netcdf_datasets["tasmax"]),
wps_literal_input("thresh", "30 degC"),
]
outputs = execute_process(client, identifier, inputs)
ds = xr.open_dataset(outputs[0])
assert ds["heat_wave_index"].standard_name == _get_output_standard_name(identifier)
def test_missing_options(client, netcdf_datasets):
identifier = "tg_mean"
inputs = [
wps_input_file("tas", netcdf_datasets["tas_missing"]),
wps_literal_input("freq", "YS"),
]
outputs = execute_process(client, identifier, inputs)
ds = xr.open_dataset(outputs[0])
np.testing.assert_array_equal(ds.tg_mean.isnull(), True)
inputs = [
wps_input_file("tas", netcdf_datasets["tas_missing"]),
wps_literal_input("freq", "YS"),
wps_literal_input("check_missing", "pct"),
wps_literal_input("missing_options", json.dumps({"pct": {"tolerance": 0.1}}))
]
outputs = execute_process(client, identifier, inputs)
ds = xr.open_dataset(outputs[0])
np.testing.assert_array_equal(ds.tg_mean.isnull(), False)
def test_stats_process(client, netcdf_datasets):
"""Test stats and the capacity to choose the variable."""
identifier = "stats"
inputs = [
wps_input_file("da", netcdf_datasets["pr_discharge"]),
wps_literal_input("freq", "YS"),
wps_literal_input("op", "max"),
wps_literal_input("season", "JJA"),
wps_literal_input("variable", "discharge")
]
outputs = execute_process(client, identifier, inputs)
ds = xr.open_dataset(outputs[0])
np.testing.assert_array_equal(ds.qsummermax.isnull(), False)
def test_freqanalysis_process(client, netcdf_datasets):
identifier = "freq_analysis"
inputs = [
wps_input_file("da", netcdf_datasets["discharge"]),
wps_literal_input("t", "2"),
wps_literal_input("t", "50"),
wps_literal_input("freq", "YS"),
wps_literal_input("mode", "max"),
wps_literal_input("season", "JJA"),
wps_literal_input("dist", "gumbel_r"),
wps_literal_input("variable", "discharge")
]
outputs = execute_process(client, identifier, inputs)
ds = xr.open_dataset(outputs[0])
np.testing.assert_array_equal(ds.q1maxsummer.shape, (2, 5, 6))
class TestFitProcess:
identifier = "fit"
def test_simple(self, client, netcdf_datasets):
inputs = [
wps_input_file("da", netcdf_datasets["discharge"]),
wps_literal_input("dist", "norm"),
]
outputs = execute_process(client, self.identifier, inputs)
ds = xr.open_dataset(outputs[0])
np.testing.assert_array_equal(ds.params.shape, (2, 5, 6))
def test_nan(self, client, q_series, tmp_path):
q_series([333, 145, 203, 109, 430, 230, np.nan]).to_netcdf(tmp_path / "q.nc")
inputs = [
wps_input_file("da", tmp_path / "q.nc"),
wps_literal_input("dist", "norm"),
]
outputs = execute_process(client, self.identifier, inputs)
ds = xr.open_dataset(outputs[0])
np.testing.assert_array_equal(ds.params.isnull(), False)
def test_rain_approximation(client, pr_series, tas_series, tmp_path):
identifier = "prlp"
pr_series(np.ones(10)).to_netcdf(tmp_path / 'pr.nc')
tas_series( | np.arange(10) | numpy.arange |
import copy
import gc
import glob
import os
import warnings
import aplpy
import linetools.utils as ltu
import numpy as np
import numpy.ma as ma
import pyregion
from astropy import units as u
from astropy.coordinates import SkyCoord
from astropy.io import fits
from astropy.io.ascii.sextractor import SExtractor
from astropy.modeling import models, fitting
from astropy.table import Table
from astropy.utils import isiterable
from linetools.spectra.xspectrum1d import XSpectrum1D
from linetools.utils import name_from_coord
from matplotlib import pyplot as plt
from scipy import interpolate
from scipy import ndimage
import PyMUSE.utils as mcu
class MuseCube:
"""
Class to handle VLT/MUSE data
"""
def __init__(self, filename_cube, filename_white=None, pixelsize=0.2 * u.arcsec, n_fig=1,
flux_units=1E-20 * u.erg / u.s / u.cm ** 2 / u.angstrom, vmin=None, vmax=None, wave_cal='air'):
"""
Parameters
----------
filename_cube: string
Name of the MUSE datacube .fits file
filename_white: string
Name of the MUSE white image .fits file
pixel_size : float or Quantity, optional
Pixel size of the datacube, if float it assumes arcsecs.
Default is 0.2 arcsec
n_fig : int, optional
XXXXXXXX
flux_units : Quantity
XXXXXXXXXX
"""
# init
self.color = False
self.cmap = ""
self.flux_units = flux_units
self.n = n_fig
plt.close(self.n)
self.wave_cal = wave_cal
self.filename = filename_cube
self.filename_white = filename_white
self.load_data()
self.white_data = fits.open(self.filename_white)[1].data
self.hdulist_white = fits.open(self.filename_white)
self.white_data = np.where(self.white_data < 0, 0, self.white_data)
if not vmin:
self.vmin=np.nanpercentile(self.white_data,0.25)
else:
self.vmin = vmin
if not vmax:
self.vmax=np.nanpercentile(self.white_data,98.)
else:
self.vmax = vmax
self.gc2 = aplpy.FITSFigure(self.filename_white, figure=plt.figure(self.n))
self.gc2.show_grayscale(vmin=self.vmin, vmax=self.vmax)
# self.gc = aplpy.FITSFigure(self.filename, slices=[1], figure=plt.figure(20))
self.pixelsize = pixelsize
gc.enable()
# plt.close(20)
print("MuseCube: Ready!")
def load_data(self):
hdulist = fits.open(self.filename)
print("MuseCube: Loading the cube fluxes and variances...")
# import pdb; pdb.set_trace()
self.cube = ma.MaskedArray(hdulist[1].data)
self.stat = ma.MaskedArray(hdulist[2].data)
print("MuseCube: Defining master masks (this may take a while but it is for the greater good).")
# masking
self.mask_init = np.isnan(self.cube) | np.isnan(self.stat)
self.cube.mask = self.mask_init
self.stat.mask = self.mask_init
# for ivar weighting ; consider creating it in init ; takes long
# self.flux_over_ivar = self.cube / self.stat
self.header_1 = hdulist[1].header # Necesito el header para crear una buena copia del white.
self.header_0 = hdulist[0].header
if self.filename_white is None:
print("MuseCube: No white image given, creating one.")
w_data = copy.deepcopy(self.create_white(save=False).data)
w_header_0 = copy.deepcopy(self.header_0)
w_header_1 = copy.deepcopy(self.header_1)
# These loops remove the third dimension from the header's keywords. This is neccesary in order to
# create the white image and preserve the cube astrometry
for i in w_header_0.keys():
if '3' in i:
del w_header_0[i]
for i in w_header_1.keys():
if '3' in i:
del w_header_1[i]
# prepare the header
hdu = fits.HDUList()
hdu_0 = fits.PrimaryHDU(header=w_header_0)
hdu_1 = fits.ImageHDU(data=w_data, header=w_header_1)
hdu.append(hdu_0)
hdu.append(hdu_1)
hdu.writeto('new_white.fits', clobber=True)
self.filename_white = 'new_white.fits'
print("MuseCube: `new_white.fits` image saved to disk.")
def color_gui(self, cmap):
"""
Function to change the cmap of the canvas
:param cmap: string. matplotlib's color map. cmap = 'none' to gray scale again
:return:
"""
if cmap == 'none':
self.color = False
self.cmap = ""
else:
self.color = True
self.cmap = cmap
self.reload_canvas()
def get_smoothed_white(self, npix=2, save=True, show=False, **kwargs):
"""Gets an smoothed version (Gaussian of sig=npix)
of the white image. If save is True, it writes a file
to disk called `smoothed_white.fits`.
**kwargs are passed down to scipy.ndimage.gaussian_filter()
"""
hdulist = self.hdulist_white
im = self.white_data
if npix > 0:
smooth_im = ndimage.gaussian_filter(im, sigma=npix, **kwargs)
else:
smooth_im = im
if save:
hdulist[1].data = smooth_im
prihdr = hdulist[0].header
comment = 'Spatially smoothed with a Gaussian kernel of sigma={} spaxels (by MuseCube)'.format(npix)
# print(comment)
prihdr['history'] = comment
hdulist.writeto('smoothed_white.fits', clobber=True)
if show:
fig = aplpy.FITSFigure('smoothed_white.fits', figure=plt.figure())
fig.show_grayscale(vmin=self.vmin,vmax=self.vmax)
return smooth_im
def spec_to_vacuum(self, spectrum):
spectrum_vac = spectrum
if self.wave_cal == 'air':
spectrum_vac.meta['airvac'] = 'air'
spectrum_vac.airtovac()
return spectrum_vac
else:
return spectrum_vac
def spatial_smooth(self, npix, output="smoothed.fits", test=False, **kwargs):
"""Applies Gaussian filter of std=npix in both spatial directions
and writes it to disk as a new MUSE Cube.
Notes: the STAT cube is not touched.
Parameters
----------
npix : int
Std of Gaussian kernel in spaxel units.
output : str, optional
Name of the output file
test : bool, optional
Whether to check for flux being conserved
**kwargs are passed down to scipy.ndimage.gaussian_filter()
Return
------
Writes a new file to disk.
"""
if not isinstance(npix, int):
raise ValueError("npix must be integer.")
cube_new = copy.deepcopy(self.cube)
ntot = len(self.cube)
for wv_ii in range(ntot):
print('{}/{}'.format(wv_ii + 1, ntot))
image_aux = self.cube[wv_ii, :, :]
smooth_ii = ma.MaskedArray(ndimage.gaussian_filter(image_aux, sigma=npix, **kwargs))
smooth_ii.mask = image_aux.mask | np.isnan(smooth_ii)
# test the fluxes are conserved
if test:
gd_pix = ~smooth_ii.mask
try:
med_1 = np.nansum(smooth_ii[gd_pix])
med_2 = np.nansum(image_aux[gd_pix])
print(med_1, med_2, (med_1 - med_2) / med_1)
np.testing.assert_allclose(med_1, med_2, decimal=4)
except AssertionError:
import pdb
pdb.set_trace()
cube_new[wv_ii, :, :] = smooth_ii
# import pdb; pdb.set_trace()
hdulist = fits.open(self.filename)
hdulist[1].data = cube_new.data
prihdr = hdulist[0].header
comment = 'Spatially smoothed with a Gaussian kernel of sigma={} spaxels (by MuseCube)'.format(npix)
print(comment)
prihdr['history'] = comment
hdulist.writeto(output, clobber=True)
print("MuseCube: new smoothed cube written to {}".format(output))
def get_mini_image(self, center, halfsize=15):
"""
:param center: tuple of coordinates, in pixels
:param size: length of the square around center
:return: ndarray which contain the image
"""
side = 2 * halfsize + 1
image = [[0 for x in range(side)] for y in range(side)]
data_white = fits.open(self.filename_white)[1].data
center_x = center[0]
center_y = center[1]
for i in xrange(center_x - halfsize - 1, center_x + halfsize):
for j in xrange(center_y - halfsize - 1, center_y + halfsize):
i2 = i - (center_x - halfsize)
j2 = j - (center_y - halfsize)
image[j2][i2] = data_white[j - 1][i - 1]
return image
def get_gaussian_seeing_weighted_spec(self, x_c, y_c, radius, seeing=4):
"""
Function to extract the spectrum of a circular aperture defined by x_c, y_c and radius in spaxel space.
The spectrum is weighted by a 2d gaussian centered at the center of the aperture, with a std = seeing in spaxels
:param x_c: x coordinate of the center of the aperture (spaxel)
:param y_c: y coordiante of the center of the aperture (spaxel)
:param radius: radius of the circular aperture
:param seeing: standard deviation of the gaussian in spaxels
:return: XSpectrum1D object
"""
import scipy.ndimage.filters as fi
new_3dmask = self.get_mini_cube_mask_from_ellipse_params(x_c, y_c, radius)
w = self.wavelength
n = len(w)
fl = np.zeros(n)
sig = np.zeros(n)
self.cube.mask = new_3dmask
for wv_ii in range(n):
mask = new_3dmask[wv_ii]
center = np.zeros(mask.shape) ###Por alguna razon no funciona si cambio la asignacion a np.zeros_like(mask)
center[y_c][x_c] = 1
weigths = ma.MaskedArray(fi.gaussian_filter(center, seeing))
weigths.mask = mask
weigths = weigths / np.sum(weigths)
fl[wv_ii] = np.sum(self.cube[wv_ii] * weigths)
sig[wv_ii] = np.sqrt(np.sum(self.stat[wv_ii] * (weigths ** 2)))
self.cube.mask = self.mask_init
return XSpectrum1D.from_tuple((w, fl, sig))
def get_spec_spaxel(self, x, y, coord_system='pix', n_figure=2, empirical_std=False, save=False):
"""
Gets the spectrum of a single spaxel (xy) of the MuseCube
:param x: x coordinate of the spaxel
:param y: y coordinate of the spaxel
:param coord_system: 'pix' or 'wcs'
:return: spec: XSpectrum1D object
"""
if coord_system == 'wcs':
x_c, y_c = self.w2p(x, y)
x_world, y_world = x, y
else:
x_c, y_c = x, y
x_world, y_world = self.p2w(x, y)
region_string = self.ellipse_param_to_ds9reg_string(x_c, y_c, 1, 1, 0, coord_system='pix')
self.draw_pyregion(region_string)
w = self.wavelength
n = len(w)
spec = np.zeros(n)
sigma = np.zeros(n)
for wv_ii in range(n):
spec[wv_ii] = self.cube.data[wv_ii][int(y_c)][int(x_c)]
sigma[wv_ii] = np.sqrt(self.stat.data[wv_ii][int(y_c)][int(x_c)])
spec = XSpectrum1D.from_tuple((self.wavelength, spec, sigma))
if empirical_std:
spec = mcu.calculate_empirical_rms(spec)
spec = self.spec_to_vacuum(spec)
plt.figure(n_figure)
plt.plot(spec.wavelength, spec.flux)
coords = SkyCoord(ra=x_world, dec=y_world, frame='icrs', unit='deg')
name = name_from_coord(coords)
plt.title(name)
plt.xlabel('Angstroms')
plt.ylabel('Flux (' + str(self.flux_units) + ')')
if save:
spec.write_to_fits(name + '.fits')
return spec
def get_spec_from_ellipse_params(self, x_c, y_c, params, coord_system='pix', mode='wwm', npix=0, frac=0.1,
n_figure=2, empirical_std=False, save=False, color='green'):
"""
Obtains a combined spectrum of spaxels within a geometrical region defined by
x_c, y_c, param
:param x_c: x coordinate of the center of the ellipse
:param y_c: y coordinate of the center of the ellipse
:param params: Either a float that will be interpreted as a radius, or an iterable [a,b,theta] with the ellipse parameters
:param coord_system: str. Default = 'pix'.
If coord_system = 'wcs' the coordinates will be considered as degrees
:param mode: str
Mode for combining spaxels:
* `ivar` - Inverse variance weighting, variance is taken only spatially, from a "white variance image"
* `sum` - Sum of total flux
* `gaussian` - Weighted mean. Weights are obtained from a 2D gaussian fit of the bright profile
* `wwm` - 'White Weighted Mean'. Weigted mean, weights are obtained from the white image, smoothed using a gaussian filter of sigma = npix. If npix=0, no smooth is done
* `ivarwv` - Weighted mean, the weight of every pixel is given by the inverse of it's variance
* `mean` - Mean of the total flux
* `median` - Median of the total flux
* `wwm_ivarwv' - Weights given by both, `ivarwv` and `wwm`
* `wwm_ivar` - Weights given by both, `wwm` and `ivar`
* `wfrac` - It only takes the fraction `frac` of brightest spaxels (white) in the region
(e.g. frac=0.1 means 10% brightest) with equal weight.
:param frac. FLoat, default = 0.1
Parameter needed for wfrac mode
:param npix: int. Default = 0
Standard deviation of the gaussian filter to smooth (Only in wwm methods)
:param n_figure: int. Default = 2. Figure to display the spectrum
:param empirical_std: boolean. Default = False.
If True, the errors of the spectrum will be determined empirically
:param save: boolean. Default = False
If True, the spectrum will be saved in hard_disk
:return: spec: XSpectrum1D object
"""
if mode == 'gaussian':
spec = self.get_gaussian_profile_weighted_spec(x_c=x_c, y_c=y_c, params=params)
else:
new_mask = self.get_mini_cube_mask_from_ellipse_params(x_c, y_c, params, coord_system=coord_system,color=color)
spec = self.spec_from_minicube_mask(new_mask, mode=mode, npix=npix, frac=frac)
if empirical_std:
spec = mcu.calculate_empirical_rms(spec)
spec = self.spec_to_vacuum(spec)
plt.figure(n_figure)
plt.plot(spec.wavelength, spec.flux)
if coord_system == 'wcs':
x_world, y_world = x_c, y_c
else:
x_world, y_world = self.p2w(x_c, y_c)
coords = SkyCoord(ra=x_world, dec=y_world, frame='icrs', unit='deg')
name = name_from_coord(coords)
plt.title(name)
plt.xlabel('Angstroms')
plt.ylabel('Flux (' + str(self.flux_units) + ')')
if save:
spec.write_to_fits(name + '.fits')
return spec
def get_spec_from_interactive_polygon_region(self, mode='wwm', npix=0, frac=0.1,
n_figure=2,
empirical_std=False, save=False):
"""
Function used to interactively define a region and extract the spectrum of that region
To use this function, the class must have been initialized in a "ipython --pylab qt" enviroment
It's also needed the package roipoly. Installation instructions and LICENSE in:
https://github.com/jdoepfert/roipoly.py/
:param mode: str, default = wwm
Mode for combining spaxels:
* `ivar` - Inverse variance weighting, variance is taken only spatially, from a "white variance image"
* `sum` - Sum of total flux
* `wwm` - 'White Weighted Mean'. Weigted mean, weights are obtained from the white image, smoothed using a gaussian filter of sigma = npix. If npix=0, no smooth is done
* `ivarwv` - Weighted mean, the weight of every pixel is given by the inverse of it's variance
* `mean` - Mean of the total flux
* `median` - Median of the total flux
* `wwm_ivarwv' - Weights given by both, `ivarwv` and `wwm`
* `wwm_ivar` - Weghts given by both, `wwm` and `ivar`
* `wfrac` - It only takes the fraction `frac` of brightest spaxels (white) in the region
(e.g. frac=0.1 means 10% brightest) with equal weight.
:param frac. FLoat, default = 0.1
Parameter needed for wfrac mode
:param npix: int. Default = 0
Standard deviation of the gaussian filter to smooth (Only in wwm methods)
:param n_figure: int. Default = 2. Figure to display the spectrum
:param empirical_std: boolean. Default = False
If True, the errors of the spectrum will be determined empirically
:param save: boolean. Default = False
If True, the spectrum will be saved in hard_disk
:return: spec: XSpectrum1D object
"""
from roipoly import roipoly
current_fig = plt.figure(self.n)
MyROI = roipoly(roicolor='r', fig=current_fig)
raw_input("MuseCube: Please select points with left click. Right click and Enter to continue...")
print("MuseCube: Calculating the spectrum...")
mask = MyROI.getMask(self.white_data)
mask_inv = np.where(mask == 1, 0, 1)
complete_mask = self.mask_init + mask_inv
new_3dmask = np.where(complete_mask == 0, False, True)
spec = self.spec_from_minicube_mask(new_3dmask, mode=mode, npix=npix, frac=frac)
self.reload_canvas()
plt.figure(n_figure)
plt.plot(spec.wavelength, spec.flux)
plt.ylabel('Flux (' + str(self.flux_units) + ')')
plt.xlabel('Wavelength (Angstroms)')
plt.title('Polygonal region spectrum ')
plt.figure(self.n)
MyROI.displayROI()
if empirical_std:
spec = mcu.calculate_empirical_rms(spec)
spec = self.spec_to_vacuum(spec)
if save:
spec.write_to_fits('Poligonal_region_spec.fits')
return spec
def params_from_ellipse_region_string(self, region_string, deg=False):
"""
Function to get the elliptical parameters of a region_string.
If deg is True, only will be returned the center in degrees.
Otherwise, all parameters will be returned in pixels
:param region_string: Region defined as string using ds9 format
:param deg: If True, only the center of the ellipse will be returned, in degrees.
:return: x_center,y_center,params, parameter of the ellipse defined in region_string
"""
r = pyregion.parse(region_string)
if deg:
x_c, y_c = r[0].coord_list[0], r[0].coord_list[1]
if r[0].coord_format == 'physical' or r[0].coord_format == 'image':
x_world, y_world = self.p2w(x_c - 1, y_c - 1)
else:
x_world, y_world = x_c, y_c
return x_world, y_world
else:
if r[0].coord_format == 'physical' or r[0].coord_format == 'image':
x_c, y_c, params = r[0].coord_list[0], r[0].coord_list[1], r[0].coord_list[2:5]
else:
x_world = r[0].coord_list[0]
y_world = r[0].coord_list[1]
par = r[0].coord_list[2:5]
x_c, y_c, params = self.ellipse_params_to_pixel(x_world, y_world, params=par)
return x_c - 1, y_c - 1, params
def get_spec_from_region_string(self, region_string, mode='wwm', npix=0., frac=0.1, empirical_std=False, n_figure=2,
save=False):
"""
Obtains a combined spectrum of spaxels within geametrical region defined by the region _string, interpretated by ds9
:param region_string: str
Region defined by a string, using ds9 format (ellipse only in gaussian method)
example: region_string = 'physical;ellipse(100,120,10,5,35) # color = green'
:param mode: str
Mode for combining spaxels:
* `ivar` - Inverse variance weighting, variance is taken only spatially, from a "white variance image"
* `sum` - Sum of total flux
* `gaussian` - Weighted mean. Weights are obtained from a 2D gaussian fit of the bright profile (for elliptical regions only)
* `wwm` - 'White Weighted Mean'. Weigted mean, weights are obtained from the white image, smoothed using a gaussian filter of sigma = npix. If npix=0, no smooth is done
* `ivarwv` - Weighted mean, the weight of every pixel is given by the inverse of it's variance
* `mean` - Mean of the total flux
* `median` - Median of the total flux
* `wwm_ivarwv' - Weights given by both, `ivarwv` and `wwm`
* `wwm_ivar` - Weghts given by both, `wwm` and `ivar`
* `wfrac` - It only takes the fraction `frac` of brightest spaxels (white) in the region
(e.g. frac=0.1 means 10% brightest) with equal weight.
:param frac. Float, default = 0.1
Parameter needed for wfrac mode
:param npix: int. Default = 0
Standard deviation of the gaussian filter to smooth (Only in wwm methods)
:param n_figure: int. Default = 2. Figure to display the spectrum
:param empirical_std: boolean. Default = False.
If True, the errors of the spectrum will be determined empirically
:param save: boolean. Default = False
If True, the spectrum will be saved in hard_disk
:return: spec: XSpectrum1D object
"""
if mode == 'gaussian':
spec = self.get_gaussian_profile_weighted_spec(region_string_=region_string)
else:
new_mask = self.get_mini_cube_mask_from_region_string(region_string)
spec = self.spec_from_minicube_mask(new_mask, mode=mode, npix=npix, frac=frac)
if empirical_std:
spec = mcu.calculate_empirical_rms(spec)
self.draw_pyregion(region_string)
spec = self.spec_to_vacuum(spec)
plt.figure(n_figure)
plt.plot(spec.wavelength, spec.flux)
x_world, y_world = self.params_from_ellipse_region_string(region_string, deg=True)
coords = SkyCoord(ra=x_world, dec=y_world, frame='icrs', unit='deg')
name = name_from_coord(coords)
plt.title(name)
plt.xlabel('Angstroms')
plt.ylabel('Flux (' + str(self.flux_units) + ')')
if save:
spec.write_to_fits(name + '.fits')
return spec
def draw_ellipse_params(self, xc, yc, params, color='green'):
"""
Function to draw in the interface the contour of the elliptical region defined by (xc,yc,params)
:param xc: x coordinate of the center of the ellipse
:param yc: y coordinate of the center of the ellipse
:param params: either a single radius or [a,b,theta] iterable
:param color: color to draw
:return:
"""
if isinstance(params, (float, int)):
params = [params, params, 0]
region_string = self.ellipse_param_to_ds9reg_string(xc, yc, params[0], params[1], params[2], color=color)
self.draw_pyregion(region_string)
def draw_pyregion(self, region_string):
"""
Function used to draw in the interface the contour of the region defined by region_string
:param region_string: str. Region defined by a string using ds9 format
:return: None
"""
hdulist = self.hdulist_white
r = pyregion.parse(region_string).as_imagecoord(hdulist[1].header)
fig = plt.figure(self.n)
ax = fig.axes[0]
patch_list, artist_list = r.get_mpl_patches_texts(origin=0)
patch = patch_list[0]
ax.add_patch(patch)
def spec_from_minicube_mask(self, new_3dmask, mode='wwm', npix=0, frac=0.1):
"""Given a 3D mask, this function provides a combined spectrum
of all non-masked voxels.
Parameters
----------
new_3dmask : np.array of same shape as self.cube
The 3D mask
mode : str
Mode for combining spaxels:
* `ivar` - Inverse variance weighting, variance is taken only spatially, from a "white variance image"
* `sum` - Sum of total flux
* `wwm` - 'White Weighted Mean'. Weigted mean, weights are obtained from the white image, smoothed using a gaussian filter of sigma = npix. If npix=0, no smooth is done
* `ivarwv` - Weighted mean, the weight of every pixel is given by the inverse of it's variance
* `mean` - Mean of the total flux
* `median` - Median of the total flux
* `wwm_ivarwv' - Weights given by both, `ivarwv` and `wwm`
* `wwm_ivar` - Weghts given by both, `wwm` and `ivar`
* `wfrac` - It only takes the fraction `frac` of brightest spaxels (white) in the region
(e.g. frac=0.1 means 10% brightest) with equal weight.
Returns
-------
An XSpectrum1D object (from linetools) with the combined spectrum.
"""
if mode not in ['ivarwv', 'ivar', 'mean', 'median', 'wwm', 'sum', 'wwm_ivarwv', 'wwm_ivar', 'wfrac']:
raise ValueError("Not ready for this type of `mode`.")
if np.shape(new_3dmask) != np.shape(self.cube.mask):
raise ValueError("new_3dmask must be of same shape as the original MUSE cube.")
n = len(self.wavelength)
fl = np.zeros(n)
er = np.zeros(n)
if mode == 'ivar':
var_white = self.create_white(stat=True, save=False)
elif mode in ['wwm', 'wwm_ivarwv', 'wwm_ivar', 'wfrac']:
smoothed_white = self.get_smoothed_white(npix=npix, save=False)
if mode == 'wwm_ivar':
var_white = self.create_white(stat=True, save=False)
elif mode == 'wfrac':
mask2d = new_3dmask[1]
self.wfrac_show_spaxels(frac=frac, mask2d=mask2d, smoothed_white=smoothed_white)
warn = False
for wv_ii in xrange(n):
mask = new_3dmask[wv_ii] # 2-D mask
im_fl = self.cube[wv_ii][~mask] # this is a 1-d np.array()
im_var = self.stat[wv_ii][~mask] # this is a 1-d np.array()
if len(im_fl) == 0:
fl[wv_ii] = 0
er[wv_ii] = 99
elif mode == 'wwm':
im_weights = smoothed_white[~mask]
n_weights = len(im_weights)
im_weights = np.where(np.isnan(im_weights), 0, im_weights)
if np.sum(im_weights) == 0:
im_weights[:] = 1. / n_weights
warn = True
im_weights = im_weights / np.sum(im_weights)
fl[wv_ii] = np.sum(im_fl * im_weights)
er[wv_ii] = np.sqrt(np.sum(im_var * (im_weights ** 2)))
elif mode == 'ivar':
im_var_white = var_white[~mask]
im_weights = 1. / im_var_white
n_weights = len(im_weights)
im_weights = np.where(np.isnan(im_weights), 0, im_weights)
if | np.sum(im_weights) | numpy.sum |
#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
from __future__ import division, print_function
"""diffacto.diffacto: provides entry point main()."""
__version__ = "1.0.5"
import csv
import re
import warnings
from collections import defaultdict
from multiprocessing import Pool
from scipy import optimize, stats
import networkx as nx
import numpy as np
import pandas
from numpy import array, isfinite, nanmean, nansum
from pyteomics import fasta
# from numba import jit # # Enable just-in-time compiler for speeding up
# @jit
def fast_farms(
probes: np.array,
weight: float = 0.5,
mu: float = 0,
max_iter: int = 1000,
force_iter: bool = False,
min_noise: float = 1e-4,
fill_nan: float = 0.0,
):
"""Bayesian Factor Analysis for Proteomics Summarization
A python translation of function "generateExprVal.method.farms" from
Bioconductor FARMS.
[http://www.bioconductor.org/packages/release/bioc/html/farms.html]
[http://www.bioinf.jku.at/publications/papers/farms/supplementary.ps]
Reference:
<NAME>, <NAME> and <NAME> (2006). A new summarization
method for affymetrix probe level data. Bioinformatics, 22(8),
http://bioinformatics.oxfordjournals.org/cgi/content/abstract/22/8/943.
Inputs:
probes: Peptide abundance array (N peptides, M samples) in log scale.
weight: Hyperparameter (backscale factor) value in the range of [0,1]
which determines the influence of the prior.
mu: Hyperparameter value which allows to quantify different aspects
of potential prior knowledge. A value near zero assumes that
most genes do not contain a signal, and introduces a bias for
loading matrix elements near zero. """
readouts = np.array(probes)
if fill_nan != 0:
readouts[np.isnan(readouts)] = fill_nan
# normalize and transform X
X = np.nan_to_num(readouts).T
X = X - np.nanmean(X, axis=0)
xsd = np.nanstd(X, axis=0)
xsd[xsd < min_noise] = 1.0
X /= xsd
X[~isfinite(X)] = 0
n_samples, n_features = X.shape
C = np.cov(X.T, ddof=0)
# positive definite
C = 0.5 * (C + C.T)
C[np.where(C < 0)] = 0
# robustness
U, s, V = np.linalg.svd(C)
s[s < min_noise] = min_noise
C = U.dot(np.diag(s)).dot(V)
# initiation
λ = np.sqrt(np.diag(C) * 0.75)
ψ = np.diag(C) - λ ** 2
old_psi = ψ
old_lambda = λ
alpha = weight * n_features
E = 1.0
min_noise_square = min_noise ** 2
C_diag = np.diag(C)
for i in range(max_iter):
# E step
φ = λ / ψ
a = 1 + np.matmul(λ.reshape(1, -1), φ.reshape(-1, 1))
η = φ / a
ζ = C.dot(η.T)
E = 1 - η.dot(λ) + η.dot(ζ)
# M step
λ = ζ.T / (E + ψ * alpha)
λ = np.asarray(λ)[0]
ψ = C_diag - np.asarray(ζ)[0] * λ + ψ * alpha * λ * (mu - λ)
ψ = np.maximum(ψ, min_noise_square)
if (
ψ[-1] == old_psi[-1]
and ψ[0] == old_psi[0]
and np.array_equal(ψ, old_psi)
and np.array_equal(λ, old_lambda)
):
break
if not force_iter:
if abs(ψ - old_psi).max() / old_psi.max() < min_noise / 10:
break
old_psi = ψ
old_lambda = λ
loading = np.sqrt(E[0, 0]) * λ
φ = loading / ψ
weights = loading / loading.max() # rescale loadings to the range of [0,1]
noise = 1 / (1 + np.matmul(loading.reshape(1, -1), φ.reshape(-1, 1)))
noise = noise[0, 0]
return weights, noise
# @jit(nogil=True)
def fast_gmean_nomissing(weights, pep_abd, group_ix):
"""
Calculate geometric means based on non-missing peptide readouts.
"""
abd_w = pep_abd * weights[..., None]
one_w = abd_w / abd_w * weights[..., None]
a_sums = np.nansum(abd_w, axis=0)
w_sums = np.nansum(one_w, axis=0)
expr = a_sums[group_ix].sum(axis=1) / w_sums[group_ix].sum(axis=1)
return expr
# @jit(nogil=True)
def sum_squares(pep_abd, group_ix, estimates):
"""
Calculate sum of squared residuals
"""
global nGroups
residual = 0.0
for i in range(nGroups):
res = pep_abd[:, group_ix[i]] - estimates[i]
residual += np.nansum(res * res)
return residual
# @jit(nogil=True)
def f_ANOVA(pep_abd, group_ix, estimates, null_ave, dof_loss=0):
"""
Perform ANOVA
Inputs:
pep_abd: Peptide abundance matrix
group_ix: Index of sample groups
estimates: Estimated abundances of sample groups
null_ave: Global average
dof_loss: Loss of dof due to averaging
Return:
f: Value of F-statistic
dof1: Degree of freedom of model 1
dof2: Degree of freedom of model 2
"""
global nGroups
ss_total = sum_squares(pep_abd, group_ix, null_ave)
ss_resid = sum_squares(pep_abd, group_ix, estimates)
dof1 = nGroups - 1
dof2 = isfinite(pep_abd).sum() - nGroups - dof_loss
if dof2 <= 0:
return np.nan, dof1, dof2
f = ((ss_total - ss_resid) / dof1) / (ss_resid / dof2)
return f, dof1, dof2
def mv_impute(pep_abd, group_ix, least_missing=0.99, impute_as=0.001):
""" Impute missing values when having a large proportion in a sample group.
Inputs:
pep_abd: n peptides, m samples, in linear scale
group_ix: grouping index for each of the m samples
least_missing: set the minimum threshold of missing rate to trigger the imputation (Default: 99%).
impute_as: set missing values in the sample to this value
Return:
numpy array after replacing missing values with imputed values
"""
aT = np.array(pep_abd).T
for ix in group_ix:
if np.isnan(aT[ix]).sum() > least_missing * len(aT[ix].flatten()):
val = aT[ix]
val[np.where(np.isnan(val))] = impute_as
aT[ix] = val
return aT.T
# @jit(nogil=True)
def weighted_average(weights, pep_abd, group_ix):
"""
Calculate weighted geometric means for sample groups
Inputs:
weights: Weights of peptides after filtering by loading threshold
pep_abd: Peptide abundances after filtering by loading threshold
group_ix: Array indexes of sample groups
Return:
expr: Estimated expression levels
"""
global nGroups
abd_w = pep_abd * weights[..., None]
count_peptides = np.sum(~np.isnan(pep_abd), axis = 0)
one_w = abd_w / abd_w * weights[..., None]
a_sums = np.nansum(abd_w, axis=0)
w_sums = | np.nansum(one_w, axis=0) | numpy.nansum |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.