prompt
stringlengths 19
879k
| completion
stringlengths 3
53.8k
| api
stringlengths 8
59
|
|---|---|---|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
################################################## ##############################
######################### Detection module #########################
######################### ######################### #############################
### Contains all the functions necessary to find the detection probability, including the geometries of relevant experiment
### and the main recasting functions for the various signatues (scattering, decay, monoX, invisible meson decay, etc ...
### The final functions are typically written as Fast****
### <NAME>, <NAME>, <NAME>, 29/12/2019
############
import math
import numpy as np
from scipy.optimize import minimize_scalar
from scipy import optimize as opt
from scipy.special import lambertw
import Production as br
import UsefulFunctions as uf
import Amplitudes as am
from scipy.integrate import quad
from scipy.optimize import minimize
################################################## ####################################
######################### #########################
######################### Auxilliary functions #########################
######################### #########################
######################### ######################### #########################
me=0.0005109989
mmuon=0.1056584
## ----- Fill the effective couplings for light quarks from the dictionary
def Fillg(geff):
return geff.get("gu11",0.),geff.get("gd11",0.),geff.get("gl11",0.),geff.get("gd22",0.)
## ----- Used to find the lower limit in Lambda due to the Chi2 decaying before reaching the detector
def FindShortLam(A,B,myc):
newA=A # Could be used to change a bit the boost factor for testing purposes
newB=B
myX= myc/newA/np.power(newB,1./myc)
# res=(myc/np.power(newA,1)*( np.log(myX)+ np.log(np.log(myX)) ))
# Approximation no needed -> use directly the lambertw function in scipy
res2 = -myc/np.power(newA,1)*lambertw(-1/myX,-1)
# print("Comparing approx to direct ",res/np.real(res2))
return np.power(np.real(res2),-1/4.)
## ----- Simple decay probability evaluation for a given c *tau * gamma
def ProbDecay(D,L,ctaugamma):
res= np.exp(-D/ctaugamma)*(1-np.exp(-L/ctaugamma))
return res
# ---- Used to include the Lambda dependence of the cross-section due to the limitation of the EFT approach at LHC
# ---- it assumes that the CS has been parametrised as CS = acs * Lambda^bcs in pb
def ReduceLimLHC(LimOld,acs = 0.0009,bcs=1.14,CSfull=4.,geff=1):
redpt=(LimOld<1700)
LimOld[redpt] = np.power(LimOld[redpt]*np.power(acs/CSfull,1/8.),1/(1-bcs/8.))
return LimOld
# ---- Gives back an estimate of the average boost factor depending on the source beam and for various invariant mass for chi1 chi2
## corresponding to different dominant production channels
def BoostFact(Mx,Del,beamtype):
FactInvMass=(1+1/(Del+1)) # Mx is actually Mx2 mass of the heavy state
Ep=0
mpith=134.9766/FactInvMass/1000;metath=547.862/FactInvMass/1000;
if (beamtype=="SPS"): # Data from BdNMC meson+brem production and taking the average
# Using the ratio of production from CHARM
# xMes=xi_CHARM_DP; NMes=Prod_CHARM_DP
# x,Np = uf.LoadDirectProdDP("SPS/DirectFDM_SPS",A_charm,Z_charm,PoTcharm,False)
# xiratio,ratio,notrelevant= uf.GetRatio(Np,x1,CS2,x2,lim,xlim):
Ep=np.sqrt(np.power(Mx,2)+np.power((Mx < mpith)*11 + (Mx < metath)*(Mx > mpith)*(17.) + (Mx > metath)*np.sqrt(17.*17-np.power(Mx*FactInvMass/2,2)),2))
elif (beamtype=="FnalRing"):
Ep=np.sqrt(np.power(Mx,2)+np.power((Mx < mpith)*7 + (Mx < metath)*(Mx > mpith)*8.5 + (Mx > metath)*np.sqrt(8.5*8.5-np.power(Mx*FactInvMass/2,2)),2))
elif (beamtype=="FnalBooster"):
Ep=np.sqrt(np.power(Mx,2)+np.power((Mx < mpith)*0.7 + (Mx < metath)*(Mx > mpith)*1 + (Mx > metath)*np.sqrt(1-np.power(Mx*FactInvMass/2,2)),2))
elif (beamtype=="LSND"):
Ep=np.sqrt(np.power(Mx,2)+np.power(0.12,2))
elif (beamtype=="LHC"):
Ep=np.sqrt(np.power(Mx,2)+1000**2) # From 1816.07396 and 1810.01879
else:
print("Bad beam line choice, possibilities: SPS, FnalRing, FnalBooster, LHC")
Boost=Ep/Mx
return Boost
# ---- Gives back the geometrical parameters of various experiments, as well as the corresponding beam lines.
def GeomForExp(exp):
if exp =="faser":
L=10;D=480;beamtype="LHC"
elif exp == "mathusla":
L=35;D=100;beamtype="LHC"
elif exp == "ship":
L=65;D=60;beamtype="SPS"
elif exp == "charm":
L=35;D=480;beamtype="SPS"
elif exp == "seaquest":
L=5;D=5;beamtype="FnalRing"
elif exp == "seaquest_phase2":
L=5;D=5;beamtype="FnalRing"
elif exp == "nova":
L=14.3;D=990;beamtype="FnalRing"
elif exp == "miniboone":
L=12;D=491;beamtype="FnalBooster"
elif exp == "sbnd":
L=5;D=110;beamtype="FnalBooster"
elif exp == "lsnd":
L=8.4;D=34;beamtype="LSND"
else:
print("Experiment selected: ", exp, " is not currently implemented. Possible choices: faser, mathusla, ship, seaquest, seaquest_phase2, nova, miniboone, sbnd, lsnd")
L= 0;D=0;beamtype="NotDefined"
return D,L,beamtype
################################################## ####################################
######################### #########################
######################### Scattering detection #########################
######################### #########################
######################### ################################## #########################
def FastScatLimit(exp,x_in,Lim_in, Del_in,Del,geff,optype="V"):
##### Assuming the splitting to be irrelevant --> upscattering easy to get using the beam energy
gu,gd,ge,gs=Fillg(geff)
if Del>0.5: print("Warning: recasting of scattering limits only implemented for small or zero splitting")
M2tildeToM1=( 1+1/(1+Del))/(2+Del_in)
xProd_DPtmp, NProd_DP= br.NProd_DP(exp)
xProd_DP=xProd_DPtmp/1.0 # Switching to zero splitting to avoid problems at the resonance
mymin=np.min(xProd_DP)/M2tildeToM1; # Sending M1 to M2tilde
mymax=np.max(xProd_DP)/M2tildeToM1;
xi = uf.log_sample(mymin,mymax,200)
Lam1TeV = np.full(np.size(xi),1000)
xProd_new, Prod_new= br.NProd(Del,exp,geff,optype)
Nnew = np.interp(xi, xProd_new*(1+Del), Prod_new)
xProd, NProd= br.NProd(Del,exp,geff,optype)
xi,ratio,LimDP = uf.GetRatio(NProd,xProd,NProd_DP,xProd_DP,Lim_in,x_in)
gscat=(np.abs(gu)+np.abs(gd))
EffLim =0.013*np.sqrt(xi)/np.sqrt(LimDP)*np.power(ratio,1/8.)*1000*np.sqrt(gscat)
return xi, EffLim
################################################## ####################################
######################### #########################
######################### Invisible meson decay #########################
######################### #########################
######################### ################################## #########################
def FastPi0InvLimit(xi,Lim_in,Delini,Del, geff,optype="V"):
gu,gd,ge,gs=Fillg(geff)
M2tildeToM1=( 1+1/(1+Del))/(2+Delini)
if optype == "AV":
xf=xi/M2tildeToM1
Gam1=am.GamAV_MestoXX(xi,xi*(1+Delini),br.MPi,1,1000.)
Gam2=am.GamAV_MestoXX(xf/(1+Del),xf,br.MPi,1,1000.)
Lim_out = Lim_in*np.power(gu-gd,1/2.)*np.power(Gam2/Gam1,1/4.)
else :
xf=xi/M2tildeToM1
Lim_out=Lim_in*0
return xf, Lim_out # As usual we return the limits as function of M2
################################################## ####################################
######################### #########################
######################### Missing Energy detection #########################
######################### #########################
######################### ################################## #########################
def FastMonoPhoton(exp,xin,limin,Delini,Del, geff,optype="V"):
gu,gd,ge,gs=Fillg(geff)
M2tildeToM1=( 1+1/(1+Del))/(2+Delini)
x_out=xin/M2tildeToM1; # As usual, we return the value for the heavy state chi2
return x_out, limin*np.sqrt(np.abs(ge))
################################################## ####################################
######################### #########################
######################### Mono-jet #########################
######################### #########################
######################### ################################## #########################
def FastMonoJet(exp,g_in,Lim_Up_in,Delini,Del, geff,optype="V"):
gu,gd,ge,gs=Fillg(geff)
xi_basic=uf.log_sample(0.005,5,200)
gef = np.sqrt(2*gu**2+gd**2)
if gef < np.min(g_in):
Lim_u_out=0
else:
Lim_u_out=np.interp(gef,g_in, Lim_Up_in)
Lim_full = np.full(200,Lim_u_out)
return xi_basic,Lim_full
################################################## ####################################
######################### #########################
######################### Supernovae cooling limits #########################
######################### #########################
######################### ################################## #########################
def FastSN1987Limit(limlist,Del, geff,optype="V",upperlimit=True):
xi_basic=uf.log_sample(0.005,0.3,400)
##### Currently just test the different operator and apply a naive proton scattering scaling, except from the AV case where the upper limit derives from the pi0 branching ratio
gu,gd,ge,gs=Fillg(geff)
M2tildeToM1=( 1+1/(1+Del))/(2) ### Change for scaling dle=0 initially
x_in,Lim_in=limlist[optype]
if upperlimit:
if optype == "V":
Lim_out = Lim_in*np.sqrt((np.abs(gu)+np.abs(gd)+np.abs(ge))/2 ) # Scaling based on e+e- annihilation
return xi_basic,np.interp(xi_basic,x_in/M2tildeToM1,Lim_out) # we include the possibility of production from electrons just incase -- very rough
else:
# Gam1=br.GamAV_MestoXX(x_inAV,x_inAV*(1),br.MPi,1,1000.)
# Gam2=br.GamAV_MestoXX(x_inAV,x_inAV*(1+Del),br.MPi,1,1000.)
xf=x_in/M2tildeToM1
Gam1=am.GamAV_MestoXX(x_in,x_in*(1+0),br.MPi,1,1000.)
Gam2=am.GamAV_MestoXX(xf/(1+Del),xf,br.MPi,1,1000.)
Lim_out = Lim_in*np.power(gu-gd,1/2.)*np.power(Gam2/Gam1,1/8.) # Limits from invisible pi0 decay
# print("x for SN, ",M2tildeToM1, x_inAV , Lim_inAV, Lim_out)
return xi_basic,np.interp(xi_basic,x_in/M2tildeToM1,Lim_out)
else:
if optype == "V":
Lim_out = Lim_in*np.sqrt((np.abs(gu)+np.abs(gd)) )# we include the possibility of scattering from nuclei
return xi_basic, | np.interp(xi_basic,x_in/M2tildeToM1,Lim_out) | numpy.interp |
import torch
import numpy as np
from scipy.stats import norm
from blackbox_selectinf.usecase.AR_model import AR_model
from importlib import reload
import blackbox_selectinf.usecase.AR_model
reload(blackbox_selectinf.usecase.AR_model)
from blackbox_selectinf.learning.learning import (learn_select_prob, get_weight, get_CI)
import argparse
import pickle
from statsmodels.stats.stattools import durbin_watson
parser = argparse.ArgumentParser(description='AR model inference for beta')
parser.add_argument('--basis_type', type=str, default='linear')
parser.add_argument('--idx', type=int, default=0)
parser.add_argument('--n', type=int, default=100)
parser.add_argument('--p', type=int, default=10)
parser.add_argument('--n_b', type=int, default=100)
parser.add_argument('--rho', type=float, default=0.0)
parser.add_argument('--Q_L', type=float, default=1.9)
parser.add_argument('--Q_U', type=float, default=2.2)
parser.add_argument('--upper', action='store_false', default=True)
parser.add_argument('--nrep', type=int, default=1)
parser.add_argument('--max_it', type=int, default=1)
parser.add_argument('--savemodel', action='store_true', default=False)
parser.add_argument('--modelname', type=str, default='model_')
parser.add_argument('--epochs', type=int, default=1000)
parser.add_argument('--batch_size', type=int, default=100)
parser.add_argument('--ntrain', type=int, default=1000)
parser.add_argument('--logname', type=str, default='log')
parser.add_argument('--loadmodel', action='store_true', default=False)
parser.add_argument('--verbose', action='store_true', default=False)
parser.add_argument('--thre', type=float, default=0.99)
parser.add_argument('--consec_epochs', type=int, default=5)
args = parser.parse_args()
def main():
Q_L = args.Q_L
Q_U = args.Q_U
n = args.n
p = args.p
rho = args.rho
n_b = args.n_b
ntrain = args.ntrain
max_it = args.max_it
j = args.idx
for j in range(args.idx, args.idx + args.nrep):
logs = {}
print("Start simulation {}".format(j))
# generate data
seed = j
logs['seed'] = seed
| np.random.seed(seed) | numpy.random.seed |
import numpy as np
# Sort and remove spurious eigenvalues
def print_evals(evals,n=None):
if n is None:n=len(evals)
print('{:>4s} largest eigenvalues:'.format(str(n)))
print('\n'.join('{:4d}: {:10.4e} {:10.4e}j'.format(n-c, | np.real(k) | numpy.real |
# -*- coding: utf-8 -*-
# Calculate various agreement measures.
# Copyright (C) 2012-2013 <NAME>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from __future__ import division, print_function
import itertools
import re
import numpy as np
from .core import IntervalTier, PointTier, Time
# --------------
# Fleiss's kappa
# --------------
def fleiss_observed_agreement(a):
'''Return the observed agreement for the input array.'''
def per_subject_agreement(row):
'''Return the observed agreement for the i-th subject.'''
number_of_objects = np.sum(row)
return (np.sum(np.square(row)) - number_of_objects) / (number_of_objects * (number_of_objects - 1))
row_probabilities = np.apply_along_axis(per_subject_agreement, axis=1, arr=a)
return np.mean(row_probabilities)
def fleiss_chance_agreement(a):
'''Returns the chance agreement for the input array.'''
def per_category_probabilities(a):
'''The proportion of all assignments which were to the j-th category.'''
cat_sums = np.sum(a, axis=0)
return cat_sums / np.sum(cat_sums)
return np.sum(np.square(per_category_probabilities(a)))
def fleiss_kappa(a):
'''Calculates Fleiss's kappa for the input array (with categories
in columns and items in rows).'''
p = fleiss_observed_agreement(a)
p_e = fleiss_chance_agreement(a)
return (p - p_e) / (1 - p_e)
# -------------
# Cohen's kappa
# -------------
def cohen_kappa(a):
'''Calculates Cohen's kappa for the input array.'''
totsum = np.sum(a)
colsums = np.sum(a, 0)
rowsums = np.sum(a, 1)
# Observed agreement.
p = np.sum(np.diagonal(a)) / totsum
# Chance agreement.
p_e = np.sum((colsums * rowsums) / totsum ** 2)
return (p - p_e) / (1 - p_e)
# ----------
# Scott's pi
# ----------
def scott_pi(a):
'''Calculates Scott's Pi for the input array.'''
totsum = | np.sum(a) | numpy.sum |
""" Tests for the model. """
import unittest
import sys
from numpy.testing import assert_array_almost_equal, assert_array_equal
import numpy as np
from numpy import random
from pyhacrf import Hacrf
from pyhacrf.state_machine import GeneralStateMachine, DefaultStateMachine
from pyhacrf.pyhacrf import _GeneralModel, _AdjacentModel
from pyhacrf import StringPairFeatureExtractor
TEST_PRECISION = 3
class TestHacrf(unittest.TestCase):
def test_initialize_parameters(self):
start_states = [0]
transitions = [(0, 0, (1, 1)),
(0, 1, (0, 1)),
(0, 0, (1, 0))]
states_to_classes = {0: 'a'}
state_machine = GeneralStateMachine(start_states=start_states,
transitions=transitions,
states_to_classes=states_to_classes)
n_features = 3
actual_parameters = Hacrf._initialize_parameters(state_machine, n_features)
expected_parameter_shape = (5, 3)
self.assertEqual(actual_parameters.shape, expected_parameter_shape)
def test_fit_predict(self):
incorrect = ['helloooo', 'freshh', 'ffb', 'h0me', 'wonderin', 'relaionship', 'hubby', 'krazii', 'mite', 'tropic']
correct = ['hello', 'fresh', 'facebook', 'home', 'wondering', 'relationship', 'husband', 'crazy', 'might', 'topic']
training = zip(incorrect, correct)
fe = StringPairFeatureExtractor(match=True, numeric=True)
xf = fe.fit_transform(training)
model = Hacrf()
model.fit(xf, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
expected_parameters = np.array([[-10.76945326, 144.03414923, 0.],
[31.84369748, -106.41885651, 0.],
[-52.08919467, 4.56943665, 0.],
[31.01495044, -13.0593297, 0.],
[49.77302218, -6.42566204, 0.],
[-28.69877796, 24.47127009, 0.],
[-85.34524911, 21.87370646, 0.],
[106.41949333, 6.18587125, 0.]])
print(model.parameters)
assert_array_almost_equal(model.parameters, expected_parameters,
decimal=TEST_PRECISION)
expected_probas = np.array([[1.00000000e+000, 3.51235685e-039],
[1.00000000e+000, 4.79716208e-039],
[1.00000000e+000, 2.82744641e-139],
[1.00000000e+000, 6.49580729e-012],
[9.99933798e-001, 6.62022561e-005],
[8.78935957e-005, 9.99912106e-001],
[4.84538335e-009, 9.99999995e-001],
[1.25170233e-250, 1.00000000e+000],
[2.46673086e-010, 1.00000000e+000],
[1.03521293e-033, 1.00000000e+000]])
actual_predict_probas = model.predict_proba(xf)
print(actual_predict_probas)
assert_array_almost_equal(actual_predict_probas, expected_probas,
decimal=TEST_PRECISION)
expected_predictions = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
actual_predictions = model.predict(xf)
assert_array_almost_equal(actual_predictions, expected_predictions,
decimal=TEST_PRECISION)
def test_fit_predict_regularized(self):
incorrect = ['helloooo', 'freshh', 'ffb', 'h0me', 'wonderin', 'relaionship', 'hubby', 'krazii', 'mite', 'tropic']
correct = ['hello', 'fresh', 'facebook', 'home', 'wondering', 'relationship', 'husband', 'crazy', 'might', 'topic']
training = zip(incorrect, correct)
fe = StringPairFeatureExtractor(match=True, numeric=True)
xf = fe.fit_transform(training)
model = Hacrf(l2_regularization=10.0)
model.fit(xf, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
print(model.parameters)
expected_parameters = np.array([[-0.0569188, 0.07413339, 0.],
[0.00187709, -0.06377866, 0.],
[-0.01908823, 0.00586189, 0.],
[0.01721114, -0.00636556, 0.],
[0.01578279, 0.0078614, 0.],
[-0.0139057, -0.00862948, 0.],
[-0.00623241, 0.02937325, 0.],
[0.00810951, -0.01774676, 0.]])
assert_array_almost_equal(model.parameters, expected_parameters,
decimal=TEST_PRECISION)
expected_probas = np.array([[0.5227226, 0.4772774],
[0.52568993, 0.47431007],
[0.4547091, 0.5452909],
[0.51179222, 0.48820778],
[0.46347576, 0.53652424],
[0.45710098, 0.54289902],
[0.46159657, 0.53840343],
[0.42997978, 0.57002022],
[0.47419724, 0.52580276],
[0.50797852, 0.49202148]])
actual_predict_probas = model.predict_proba(xf)
print(actual_predict_probas)
assert_array_almost_equal(actual_predict_probas, expected_probas,
decimal=TEST_PRECISION)
expected_predictions = np.array([0, 0, 1, 0, 1, 1, 1, 1, 1, 0])
actual_predictions = model.predict(xf)
assert_array_almost_equal(actual_predictions, expected_predictions,
decimal=TEST_PRECISION)
class TestGeneralModel(unittest.TestCase):
def test_build_lattice(self):
n_states = 4 # Because 3 is the max
start_states = [0, 1]
transitions = [(0, 0, (1, 1)),
(0, 1, (0, 1)),
(0, 0, (1, 0)),
(0, 3, lambda i, j, k: (0, 2))]
states_to_classes = {0: 0, 1: 1, 3: 3}
state_machine = GeneralStateMachine(start_states, transitions, states_to_classes)
x = np.zeros((2, 3, 9))
# # ________
# 1. . . # 1 0 - 10 - 31
# # | /_______
# 0. . . # 0 10 -- 1 3
# 0 1 2 # 0 1 2
#
# 1(0, 1), 3(0, 2), 1(1, 1), 1(0, 0) should be pruned because they represent partial alignments.
# Only nodes that are reachable by stepping back from (1, 2) must be included in the lattice.
actual_lattice = state_machine.build_lattice(x)
expected_lattice = np.array([(0, 0, 0, 1, 0, 0, 2 + n_states),
(0, 0, 0, 1, 1, 0, 0 + n_states),
(1, 0, 0, 1, 2, 3, 3 + n_states),
(1, 1, 0, 1, 2, 1, 1 + n_states)])
assert_array_equal(actual_lattice, expected_lattice)
def test_build_lattice_jumps(self):
n_states = 2 # Because 1 is the max
start_states = [0, 1]
transitions = [(0, 0, (1, 1)),
(0, 1, (0, 2)),
(0, 0, (1, 0))]
states_to_classes = {0: 0, 1: 1}
state_machine = GeneralStateMachine(start_states, transitions, states_to_classes)
x = np.zeros((2, 3, 9))
# # ________
# 1. . . # 1 0 . 1
# # | _______
# 0. . . # 0 10 / . 1
# 0 1 2 # 0 1 2
#
# 1(0, 2) should be pruned because they represent partial alignments.
# Only nodes that are reachable by stepping back from (1, 2) must be included in the lattice.
actual_lattice = state_machine.build_lattice(x)
expected_lattice = np.array([(0, 0, 0, 1, 0, 0, 2 + n_states),
(1, 0, 0, 1, 2, 1, 1 + n_states)])
assert_array_equal(actual_lattice, expected_lattice)
def test_forward_single(self):
start_states = [0, 1]
transitions = [(0, 0, (1, 1)),
(0, 1, (0, 1)),
(0, 0, (1, 0)),
(0, 2, lambda i, j, k: (0, 2))]
states_to_classes = {0: 'a', 1: 'a', 2: 'b'} # Dummy
state_machine = GeneralStateMachine(start_states, transitions, states_to_classes)
parameters = np.array(range(-7, 7), dtype='float64').reshape((7, 2))
# parameters =
# 0([[-7, -6],
# 1 [-5, -4],
# 2 [-3, -2],
# 3 [-1, 0],
# 4 [ 1, 2],
# 5 [ 3, 4],
# 6 [ 5, 6]])
x = np.array([[[0, 1],
[1, 0],
[2, 1]],
[[0, 1],
[1, 0],
[1, 0]]], dtype=np.float64)
y = 'a'
# Expected lattice:
# # ________
# 1. . . # 1 0 __0 - 21
# # | /
# 0. . . # 0 0
# 0 1 2 # 0 1 2
expected_alpha = {
(0, 0, 0): np.exp(-6),
(0, 0, 0, 1, 0, 0, 5): np.exp(-6) * np.exp(4),
(0, 0, 0, 1, 1, 0, 3): np.exp(-6) * np.exp(-1),
(1, 0, 0): np.exp(-6) * np.exp(4) * np.exp(-6),
(1, 0, 0, 1, 2, 2, 6): np.exp(-6) * np.exp(4) * np.exp(-6) * np.exp(5),
(1, 1, 0): np.exp(-6) * np.exp(-1) * np.exp(-7),
(1, 1, 0, 1, 2, 1, 4): np.exp(-6) * np.exp(-1) * np.exp(-7) * np.exp(1),
(1, 2, 1): np.exp(-6) * np.exp(-1) * | np.exp(-7) | numpy.exp |
"""Testing functions for UncertaintyModel parent class"""
import numpy
import unittest
import unittest.mock
import gandy.models.models as mds
import gandy.quality_est.metrics
class TestUncertaintyModel(unittest.TestCase):
@unittest.mock.patch('gandy.models.models.UncertaintyModel.build')
def test___init__(self, mocked_build):
"""Test initialization of the UncertaintyModel class"""
# first mock the build method
# initialize
subject = mds.UncertaintyModel(xshape=(6,),
yshape=(3,),
keyword=5) # keywords passed?
# test assignment of shapes
self.assertTrue(hasattr(subject, 'xshape'))
self.assertTrue(hasattr(subject, 'yshape'))
# test that build was called
mocked_build.assert_called_once_with(keyword=5)
# test that we initializzed sessions
self.assertEqual(subject.sessions, {})
self.assertTrue(hasattr(subject, 'model'))
return
@unittest.mock.patch('gandy.models.models.UncertaintyModel.build')
def test_check(self, mocked_build):
"""Test the ability of the model to recognize improper data"""
# prepare some data objects to check.
# we only have numpy available in the dependencies
# should work with other objects such as pandas dataframe
# test different dimensions
XSHAPE = [(5, 6,), (8,)]
YSHAPE = [(5,), (1,)]
for xshape, yshape in XSHAPE, YSHAPE:
Xs_good = numpy.ones(
(20, *xshape), # as if it were 20 data points
dtype=int # specify int to ensure proper conversion
)
Xs_bad = numpy.ones(
(20, 3, 4)
)
Xs_non_numeric = numpy.array(['str'])
Ys_good = numpy.ones(
(20, *yshape) # matching 20 data points
)
Ys_bad = numpy.ones(
(20, 3)
)
Ys_datacount_mismatch = numpy.ones(
(10, *yshape) # not matching 20 data points
)
no_shape_attribute = [1, 2, 3]
# prepare the subject
subject = mds.UncertaintyModel(xshape, yshape)
# first test only Xs passed
# start with expected success
Xs_out = subject.check(Xs_good)
self.assertEqual(numpy.ndarray, type(Xs_out))
self.assertEqual(Xs_good.shape, Xs_out.shape)
self.assertEqual(numpy.float64, Xs_out.dtype)
# failure modes
with self.assertRaises(ValueError):
subject.check(Xs_bad)
with self.assertRaises(TypeError):
subject.check(Xs_non_numeric)
with self.assertRaises(AttributeError):
subject.check(no_shape_attribute)
# Xs and y together
# expected success
Xs_out, Ys_out = subject.check(Xs_good, Ys_good)
self.assertTrue(isinstance(Xs_out, numpy.ndarray) and
isinstance(Ys_out, numpy.ndarray))
self.assertTrue(Xs_good.shape == Xs_out.shape and
Ys_good.shape == Ys_out.shape)
self.assertEqual(numpy.float64, Xs_out.dtype)
# failure modes
with self.assertRaises(ValueError):
subject.check(Xs_bad, Ys_good)
with self.assertRaises(ValueError):
subject.check(Xs_good, Ys_bad)
with self.assertRaises(TypeError):
subject.check(Xs_non_numeric, Ys_good)
with self.assertRaises(AttributeError):
subject.check(no_shape_attribute, Ys_good)
with self.assertRaises(AttributeError):
subject.check(Xs_good, no_shape_attribute)
with self.assertRaises(ValueError):
subject.check(Xs_good, Ys_datacount_mismatch)
return
def test_build(self):
"""Test the parent build method, to make sure it executes protected
method"""
model = 'Mymodel'
with unittest.mock.patch(
'gandy.models.models.UncertaintyModel._build',
return_value=model # mock the return of the model to a string
) as mocked__build:
subject = mds.UncertaintyModel((1,), (1,), keyword=5)
mocked__build.assert_called_once_with(keyword=5)
# ensure automatically set model
self.assertTrue(subject.model is model)
return
def test__build(self):
"""Parent _build should do nothing but raise"""
with self.assertRaises(mds.NotImplimented):
mds.UncertaintyModel((1,), (1,))
# mock _build from here on out - we don;t want the init build to
# interfere
return
@unittest.mock.patch(
'gandy.models.models.UncertaintyModel._build',
return_value='Model'
)
def test__get_metric(self, mocked__build):
"""test ability to retrieve the correct callables"""
def fake_metric(trues, predictions, uncertainties):
return 5
# initialize the subject
subject = mds.UncertaintyModel((1,), (1,))
# try all success cases
metric_out = subject._get_metric(fake_metric)
self.assertEqual(fake_metric, metric_out)
metric_out = subject._get_metric('Metric')
self.assertEqual(gandy.quality_est.metrics.Metric, metric_out)
metric_out = subject._get_metric(None)
self.assertTrue(metric_out is None)
# and failure, not a class
with self.assertRaises(AttributeError):
subject._get_metric('not_a_class')
return
@unittest.mock.patch(
'gandy.models.models.UncertaintyModel._build',
return_value='Model'
)
def test_train(self, mocked__build):
"""Proper passing of data to _train and updating of sessions"""
subject = mds.UncertaintyModel((1,), (1,))
# mock the required nested calls
Xs_in, Ys_in = 'Xs', 'Ys'
mocked_check = unittest.mock.MagicMock(
return_value=('Xs_checked', 'Ys_checked')
)
subject.check = mocked_check
mocked__train = unittest.mock.MagicMock(
return_value='losses'
)
subject._train = mocked__train
mocked__get_metric = unittest.mock.MagicMock(
return_value='some_metric'
)
subject._get_metric = mocked__get_metric
# run the train and check proper calls
with unittest.mock.patch('time.time', return_value='thetime'
) as mocked_time:
# first specify a session name
subject.train(Xs_in, Ys_in,
metric='fake_metric',
session='first_session')
mocked_check.assert_called_with(Xs_in, Ys_in)
mocked__get_metric.assert_called_with('fake_metric')
mocked__train.assert_called_with('Xs_checked',
'Ys_checked',
metric='some_metric')
# then try without specifying session name, we want to make its own
# also don't give a metric to make sure that is an allowed option
subject.train(Xs_in, Ys_in)
mocked_time.assert_called()
# check all of the correct storing of sessions
self.assertEqual(2, len(subject.sessions))
self.assertTrue('first_session' in subject.sessions.keys())
self.assertEqual(subject.sessions['first_session'], 'losses')
self.assertTrue('Starttime: thetime' in subject.sessions.keys())
return
@unittest.mock.patch(
'gandy.models.models.UncertaintyModel._build',
return_value='Model'
)
def test__train(self, mocked__build):
"""All it should do is raise an error for child to define"""
subject = mds.UncertaintyModel((1,), (1,))
with self.assertRaises(mds.NotImplimented):
subject._train('Xs', 'Ys')
return
@unittest.mock.patch(
'gandy.models.models.UncertaintyModel._build',
return_value='Model'
)
def test_predict(self, mocked__build):
"""Test proper flagging of predictions"""
subject = mds.UncertaintyModel((1,), (1,))
# prepare and mock objects
Xs_in = 'Xs'
# here we set up a rotation of predictions, uncertaintains for
# _predict to return, allowing us to test _predict output handling
_predict_return = [
([5, 10], | numpy.array([5, 10], dtype=int) | numpy.array |
"""
The goal of this script is to illustrate the results of applying kernel inference
in its simplest form to derive a best guess for a covariance function.
For this, do the following:
1. Definitions and imports
2. Simulations
3. Perform kernel inference
4. Plots and illustrations
"""
"""
1. Definitions and imports -----------------------------------------------
"""
# i) Import packages
import numpy as np
import numpy.linalg as lina
import matplotlib.pyplot as plt
plt.rcParams.update({'font.size': 5})
# ii) Define auxiliary quantities
n=100
n_simu=80
n_sample=30
n_exp=10
t=np.linspace(0,1,n)
sample_index=np.round(np.linspace(0,n-1,n_sample))
t_sample=t[sample_index.astype(int)]
tol=10**(-10)
"""
2. Simulations ----------------------------------------------------------
"""
# i) Define true underlying covariance function
d_true=0.5
def cov_fun_true(t1,t2):
return np.exp(-(lina.norm(t1-t2)/d_true)**2)
# ii) Set up Covariance matrix
K_true=np.zeros([n,n])
for k in range(n):
for l in range(n):
K_true[k,l]=cov_fun_true(t[k],t[l])
mu=np.zeros(n)
# iii) Generate simulations
x_simu=np.zeros([n,n_simu])
for k in range(n_simu):
x_simu[:,k]=np.random.multivariate_normal(mu,K_true)
x_measured=x_simu[sample_index.astype(int),:]
# iv) Create empirical covariance matrix
S_emp_full=(1/n_simu)*(x_simu@x_simu.T)
S_emp=(1/n_simu)*(x_measured@x_measured.T)
"""
3. Perform kernel inference ---------------------------------------------
"""
# i) Create prior
r=2
d_prior=0.2
def cov_fun_prior(t1,t2):
return np.exp(-(lina.norm(t1-t2)/d_prior)**2)
K_prior=np.zeros([n,n])
for k in range(n):
for l in range(n):
K_prior[k,l]=cov_fun_prior(t[k],t[l])
# ii) Set up matrices
[U_p,Lambda_p,V_p]=lina.svd(K_prior)
Lambda_p= | np.diag(Lambda_p) | numpy.diag |
import os
import math
import time
import math
import numpy as np
import pandas as pd
import argparse
import matplotlib.pyplot as plt
from ggplot import *
from pdb import set_trace as bp
from sklearn.manifold import TSNE
from mpl_toolkits.axes_grid1 import ImageGrid
parser = argparse.ArgumentParser(description='Restricted Boltzman Machine')
parser.add_argument("--lr", type=float, default=0.1, help="initial learning rate for gradient descent based algorithms")
parser.add_argument("--k", type=int, default=1, help="momentum to be used by momentum based algorithms")
parser.add_argument("--num_hidden", type=int, default=500,
help="number of hidden variable - this does not include the 784 dimensional input_x layer\
and the 10 dimensional output layer")
parser.add_argument("--batch_size", type=int, default=10,
help="the batch size to be used - valid values are 1 and multiples of 5")
parser.add_argument("--epochs", type=int, default=10, help="the no of epochs the model should run")
parser.add_argument("--save_dir", default=os.getcwd() + "/", type=str,
help="the directory in which the pickled model should be saved - by model we mean\
all the weights and biases of the network")
parser.add_argument("--train", default=os.getcwd() + "/train.csv", type=str, help="path to the Training dataset")
parser.add_argument("--test", default=os.getcwd() + "/test.csv", type=str, help="path to the Test dataset")
print("Parsing Arguments...")
args = parser.parse_args()
def make_matgrid(input_image, file_name):
fig = plt.figure(1, (20., 20.))
grid = ImageGrid(fig, 111, # similar to subplot(111)
nrows_ncols=(8, 8), # creates 2x2 grid of axes
axes_pad=0.1, # pad between axes in inch.
)
for i in range(input_image.shape[0]):
im = input_image[i:i + 1].reshape(28, 28)
grid[i].imshow(im, cmap='gray') # The AxesGrid object work as a list of axes.
plt.savefig(file_name)
plt.close('all')
def tsne_custom(x, y, filename):
feat_cols = ['pixel' + str(i) for i in range(1, 785)]
df = pd.DataFrame(x, columns=feat_cols)
df['label'] = y
df['label'] = df['label'].apply(lambda i: str(i))
rndperm = np.random.permutation(df.shape[0])
n_sne = 10000
time_start = time.time()
tsne = TSNE(n_components=2, verbose=1, perplexity=40, n_iter=300)
tsne_results = tsne.fit_transform(df.loc[rndperm[:n_sne], feat_cols].values)
print('t-SNE done! Time elapsed: {} seconds'.format(time.time() - time_start))
df_tsne = df.loc[rndperm[:n_sne], :].copy()
df_tsne['x-tsne'] = tsne_results[:, 0]
df_tsne['y-tsne'] = tsne_results[:, 1]
chart = ggplot(df_tsne, aes(x='x-tsne', y='y-tsne', color='label')) \
+ geom_point(size=70, alpha=0.5) \
+ ggtitle("tSNE dimensions colored by digit")
chart.save(filename + ".png")
plt.close('all')
class RBM(object):
"""docstring for RBM"""
def __init__(self, input=None, n_V=784, n_H=args.num_hidden, W=None, h_bias=None, v_bias=None, numpy_rng=None,):
super(RBM, self).__init__()
self.input = input
self.visible = n_V
self.hidden = n_H
if numpy_rng is None:
# create a number generator
numpy_rng = np.random.RandomState(1)
if W is None:
W = numpy_rng.uniform(
low=-4 * np.sqrt(6. / (n_H + n_V)),
high=4 * np.sqrt(6. / (n_H + n_V)),
size=(n_V, n_H)
)
if h_bias is None:
h_bias = np.zeros(n_H)
if v_bias is None:
v_bias = np.zeros(n_V)
self.W = W
self.numpy_rng = numpy_rng
self.hbias = h_bias
self.vbias = v_bias
self.params = [self.W, self.hbias, self.vbias]
def sigmoid(self, x):
return 1 / (1 + np.exp(-x))
def dsigmoid(self, y):
return y * (1.0 - y)
def propagate_up(self, visible):
pre_sigmoid = np.dot(visible, self.W) + self.hbias
post_sigmoid = self.sigmoid(pre_sigmoid)
return [pre_sigmoid, post_sigmoid]
def h_given_v(self, v0):
pre_sigmoid_h1, h1_mean = self.propagate_up(v0)
h1_sample = self.numpy_rng.binomial(n=1, p=h1_mean, size=h1_mean.shape)
return [pre_sigmoid_h1, h1_mean, h1_sample]
def propagate_down(self, hidden):
pre_sigmoid = np.dot(hidden, self.W.T) + self.vbias
post_sigmoid = self.sigmoid(pre_sigmoid)
return [pre_sigmoid, post_sigmoid]
def v_given_h(self, h0):
pre_sigmoid_v1, v1_mean = self.propagate_down(h0)
v1_sample = np.random.binomial(n=1, p=v1_mean, size=v1_mean.shape)
return [pre_sigmoid_v1, v1_mean, v1_sample]
def giibs_hvh(self, h0):
pre_sigmoid_v1, v1_mean, v1_sample = self.v_given_h(h0)
pre_sigmoid_h1, h1_mean, h1_sample = self.h_given_v(v1_sample)
return [pre_sigmoid_v1, v1_mean, v1_sample, pre_sigmoid_h1, h1_mean, h1_sample]
def giibs_vhv(self, v0):
pre_sigmoid_h1, h1_mean, h1_sample = self.h_given_v(v0)
pre_sigmoid_v1, v1_mean, v1_sample = self.v_given_h(h1_sample)
return [pre_sigmoid_h1, h1_mean, h1_sample, pre_sigmoid_v1, v1_mean, v1_sample]
def free_energy_loss(self, epsilon=10**(-3)):
pre_sigmoid_activation_h = np.dot(self.input, self.W) + self.hbias
sigmoid_activation_h = self.sigmoid(pre_sigmoid_activation_h)
pre_sigmoid_activation_v = np.dot(sigmoid_activation_h, self.W.T) + self.vbias
sigmoid_activation_v = self.sigmoid(pre_sigmoid_activation_v)
cross_entropy = - np.mean(
np.sum(self.input * np.log(sigmoid_activation_v + epsilon) +
(1 - self.input) * np.log(1 + epsilon - sigmoid_activation_v),
axis=1))
return cross_entropy
def get_update_rbm(self, lr=0.1, persistent=None, k=1):
pre_sigmoid_ph, ph_mean, ph_sample = self.h_given_v(self.input)
if persistent is None:
chain_start = ph_sample
else:
chain_start = persistent
for step in range(k):
if step == 0:
pre_sigmoid_nvs, nv_means, nv_samples, pre_sigmoid_nhs, nh_means, nh_samples = self.giibs_hvh(chain_start)
else:
pre_sigmoid_nvs, nv_means, nv_samples, pre_sigmoid_nhs, nh_means, nh_samples = self.giibs_hvh(nh_samples)
self.W += lr * ( | np.dot(self.input.T, ph_mean) | numpy.dot |
from skimage import data
import os
from skimage.filters import unsharp_mask
import matplotlib.pyplot as plt
from pathlib import Path
from skimage.morphology import (erosion, dilation, opening, closing, # noqa
white_tophat)
from skimage.morphology import disk # noqa
import numpy as np
from pyimage.ami_image import AmiImage
class Exploration:
def sharpen_explore(self, axis=False):
gray = Exploration.create_gray_network_snippet("snippet_rgba.png")
result_1_1 = unsharp_mask(gray, radius=1, amount=1)
result_5_2 = unsharp_mask(gray, radius=5, amount=2)
result_20_1 = unsharp_mask(gray, radius=20, amount=1)
plots = [
{"image": gray, "title": 'Original image'},
{"image": result_1_1, "title": 'Enhanced image, radius=1, amount=1.0'},
{"image": result_5_2, "title": 'Enhanced image, radius=5, amount=2.0'},
{"image": result_20_1, "title": 'Enhanced image, radius=20, amount=1.0'},
]
ax, fig = self.create_subplots(plots, nrows=2, ncols=2, figsize=(10, 10))
Exploration.axis_layout(ax, axis, fig)
plt.show()
def explore_erode_dilate(self):
from skimage.util import img_as_ubyte
# orig_phantom = img_as_ubyte(data.shepp_logan_phantom())
# Exploration.make_numpy_assert(orig_phantom, shape=(400, 400), max=255, dtype=np.uint8)
# fig, ax = plt.subplots()
# ax.imshow(orig_phantom, cmap=plt.cm.gray)
# plt.show()
#
# footprint = disk(6)
# Exploration.make_numpy_assert(footprint, shape=(13, 13), max=1, dtype=np.uint8)
#
# eroded = erosion(orig_phantom, footprint)
# Exploration.make_numpy_assert(eroded, shape=(400, 400), max=255)
# Exploration.plot_comparison(orig_phantom, eroded, 'erosion')
# plt.show()
#
white = Exploration.create_white_network_snippet("snippet_rgba.png")
Exploration.make_numpy_assert(white, shape=(341, 796), max=1, dtype=np.bool)
footprint = disk(1)
eroded = erosion(white, footprint)
Exploration.plot_comparison(white, eroded, 'erosion')
plt.show()
erode_1 = erosion(white, disk(1))
erode_2 = erosion(white, disk(2))
dilate_1 = dilation(white, disk(1))
dilate_2 = dilation(white, disk(2))
dilate_erode_1 = dilation(erosion(white, disk(1)), disk(1))
plots = [
{"image": white, "title": 'Original image'},
{"image": erode_1, "title": 'erode disk=1'},
{"image": erode_2, "title": 'erode disk=2'},
{"image": dilate_1, "title": 'dilate disk=1'},
{"image": dilate_2, "title": 'dilate disk=2'},
{"image": dilate_erode_1, "title": 'dilate_erode disk=1'},
]
ax, fig = self.create_subplots(plots, nrows=3, ncols=2, figsize=(10, 10))
# Exploration.axis_layout(ax, axis, fig)
plt.show()
# ================= resources =================
@classmethod
def create_gray_network_snippet(cls, png):
path = Path(Path(__file__).parent.parent, "test", "resources", png)
assert path.exists(), f"path {path} exists"
gray = AmiImage.create_grayscale_from_file(path)
return gray
@classmethod
def create_white_network_snippet(cls, png):
path = Path(Path(__file__).parent.parent, "test", "resources", png)
assert path.exists(), f"path {path} exists"
white = AmiImage.create_white_binary_from_file(path)
Exploration.make_numpy_assert(white, shape=(341, 796), max=1, dtype=np.bool)
return white
@classmethod
def plot_comparison(cls, original, modified, modified_title):
"""
Plots old/new images side-by-side
:param original:
:param modified:
:param modified_title: title of RH image
:return:
"""
fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(8, 4), sharex=True,
sharey=True)
ax1.imshow(original, cmap=plt.cm.gray)
ax1.set_title('original')
ax1.axis('off')
ax2.imshow(modified, cmap=plt.cm.gray)
ax2.set_title(modified_title)
ax2.axis('off')
@classmethod
def create_subplots(cls, plots, nrows=2, ncols=2, sharex=True, sharey=True, figsize=(10, 10)):
"""
Convenience method to create subplots
:param plots: array of ndarrays to plot
:param nrows:
:param ncols:
:param sharex:
:param sharey:
:param figsize: tuple for display (width, height in "cm" I think)
:return: ax, fig
"""
fig, axes = plt.subplots(nrows=nrows, ncols=ncols,
sharex=sharex, sharey=sharey, figsize=figsize)
ax = axes.ravel()
for i, plot in enumerate(plots):
ax[i].imshow(plots[i]["image"], cmap=plt.cm.gray)
ax[i].set_title(plots[i]["title"])
return ax, fig
@classmethod
def axis_layout(cls, ax, axis, fig):
"""
Not quite sure what it switches on/off
:param ax:
:param axis:
:param fig:
:return:
"""
if axis:
for a in ax:
a.axis('off')
fig.tight_layout()
# =========== palettes ============
"""
From https://stackoverflow.com/questions/45523205/get-rgb-colors-from-color-palette-image-and-apply-to-binary-image
You can use a combination of a reshape and np.unique to extract the unique RGB values from your color palette image:
"""
# Load the color palette
from skimage import io
raise NotImplemented("image explore, needs biosynth3??")
palette = io.imread(os.image.join(os.getcwd(), 'color_palette.png'))
# Use `np.unique` following a reshape to get the RGB values
palette = palette.reshape(palette.shape[0]*palette.shape[1], palette.shape[2])
palette_colors = | np.unique(palette, axis=0) | numpy.unique |
"""
"""
import numpy as np
from astropy.utils.misc import NumpyRNGContext
from astropy.tests.helper import pytest
from .pure_python_mean_radial_velocity_vs_r import pure_python_mean_radial_velocity_vs_r
from ..mean_radial_velocity_vs_r import mean_radial_velocity_vs_r
from ...tests.cf_helpers import generate_locus_of_3d_points, generate_3d_regular_mesh
__all__ = ('test_mean_radial_velocity_vs_r1', )
fixed_seed = 43
def test_mean_radial_velocity_vs_r1():
""" Compare <Vr> calculation to simple configuration
with exactly calculable result
"""
npts = 10
xc1, yc1, zc1 = 0.1, 0.5, 0.5
xc2, yc2, zc2 = 0.05, 0.5, 0.5
sample1 = np.zeros((npts, 3)) + (xc1, yc1, zc1)
sample2 = np.zeros((npts, 3)) + (xc2, yc2, zc2)
vx1, vy1, vz1 = 0., 0., 0.
vx2, vy2, vz2 = 20., 0., 0.
velocities1 = np.zeros((npts, 3)) + (vx1, vy1, vz1)
velocities2 = np.zeros((npts, 3)) + (vx2, vy2, vz2)
rbins = np.array([0, 0.1, 0.2, 0.3])
###########
# Run the test with PBCs turned off
result = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins, sample2=sample2, velocities2=velocities2)
assert np.allclose(result, [-20, 0, 0])
# Result should be identical with PBCs turned on
result = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins, sample2=sample2, velocities2=velocities2, period=1)
assert np.allclose(result, [-20, 0, 0])
def test_mean_radial_velocity_vs_r2():
""" Compare <Vr> calculation to simple configuration
with exactly calculable result
"""
npts = 10
xc1, yc1, zc1 = 0.05, 0.5, 0.5
xc2, yc2, zc2 = 0.95, 0.5, 0.5
sample1 = np.zeros((npts, 3)) + (xc1, yc1, zc1)
sample2 = np.zeros((npts, 3)) + (xc2, yc2, zc2)
vx1, vy1, vz1 = 0., 0., 0.
vx2, vy2, vz2 = 20., 0., 0.
velocities1 = np.zeros((npts, 3)) + (vx1, vy1, vz1)
velocities2 = np.zeros((npts, 3)) + (vx2, vy2, vz2)
rbins = np.array([0, 0.05, 0.2, 0.3])
###########
# Run the test with PBCs turned off
result = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins, sample2=sample2, velocities2=velocities2)
assert np.allclose(result, [0, 0, 0])
# Result should change with PBCs turned on
result = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins, sample2=sample2, velocities2=velocities2, period=1)
assert np.allclose(result, [0, -20, 0])
def test_mean_radial_velocity_vs_r3():
""" Brute force comparison of <Vr> calculation to pure python implementation,
with PBCs turned off, and cross-correlation is tested
"""
npts1, npts2 = 150, 151
with NumpyRNGContext(fixed_seed):
sample1 = np.random.random((npts1, 3))
sample2 = np.random.random((npts2, 3))
velocities1 = np.random.uniform(-100, 100, npts1*3).reshape((npts1, 3))
velocities2 = np.random.uniform(-100, 100, npts2*3).reshape((npts2, 3))
rbins = np.array([0, 0.05, 0.2, 0.3])
cython_result_no_pbc = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins, sample2=sample2, velocities2=velocities2)
for i, rmin, rmax in zip(range(len(rbins)), rbins[:-1], rbins[1:]):
python_result_no_pbc = pure_python_mean_radial_velocity_vs_r(
sample1, velocities1, sample2, velocities2, rmin, rmax, Lbox=float('inf'))
assert np.allclose(cython_result_no_pbc[i], python_result_no_pbc)
def test_mean_radial_velocity_vs_r4():
""" Brute force comparison of <Vr> calculation to pure python implementation,
with PBCs turned on, and cross-correlation is tested
"""
npts1, npts2 = 150, 151
with NumpyRNGContext(fixed_seed):
sample1 = np.random.random((npts1, 3))
sample2 = np.random.random((npts2, 3))
velocities1 = np.random.uniform(-100, 100, npts1*3).reshape((npts1, 3))
velocities2 = np.random.uniform(-100, 100, npts2*3).reshape((npts2, 3))
rbins = np.array([0, 0.05, 0.2, 0.3])
cython_result_pbc = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins, sample2=sample2, velocities2=velocities2, period=1.)
for i, rmin, rmax in zip(range(len(rbins)), rbins[:-1], rbins[1:]):
python_result_no_pbc = pure_python_mean_radial_velocity_vs_r(
sample1, velocities1, sample2, velocities2, rmin, rmax, Lbox=1)
assert np.allclose(cython_result_pbc[i], python_result_no_pbc)
def test_mean_radial_velocity_vs_r5():
""" Brute force comparison of <Vr> calculation to pure python implementation,
with PBCs turned off, and auto-correlation is tested
"""
npts1, npts2 = 150, 151
with NumpyRNGContext(fixed_seed):
sample1 = np.random.random((npts1, 3))
sample2 = np.random.random((npts2, 3))
velocities1 = np.random.uniform(-100, 100, npts1*3).reshape((npts1, 3))
velocities2 = np.random.uniform(-100, 100, npts2*3).reshape((npts2, 3))
sample1 = np.concatenate((sample1, sample2))
velocities1 = np.concatenate((velocities1, velocities2))
rbins = np.array([0, 0.05, 0.2, 0.3])
cython_result_no_pbc = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins)
for i, rmin, rmax in zip(range(len(rbins)), rbins[:-1], rbins[1:]):
python_result_no_pbc = pure_python_mean_radial_velocity_vs_r(
sample1, velocities1, sample1, velocities1, rmin, rmax, Lbox=float('inf'))
assert np.allclose(cython_result_no_pbc[i], python_result_no_pbc)
def test_mean_radial_velocity_vs_r6():
""" Brute force comparison of <Vr> calculation to pure python implementation,
with PBCs turned on, and auto-correlation is tested
"""
npts1, npts2 = 150, 151
with NumpyRNGContext(fixed_seed):
sample1 = np.random.random((npts1, 3))
sample2 = np.random.random((npts2, 3))
velocities1 = np.random.uniform(-100, 100, npts1*3).reshape((npts1, 3))
velocities2 = np.random.uniform(-100, 100, npts2*3).reshape((npts2, 3))
sample1 = np.concatenate((sample1, sample2))
velocities1 = np.concatenate((velocities1, velocities2))
rbins = np.array([0, 0.05, 0.2, 0.3])
cython_result_no_pbc = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins, period=1)
for i, rmin, rmax in zip(range(len(rbins)), rbins[:-1], rbins[1:]):
python_result_no_pbc = pure_python_mean_radial_velocity_vs_r(
sample1, velocities1, sample1, velocities1, rmin, rmax, Lbox=1)
assert np.allclose(cython_result_no_pbc[i], python_result_no_pbc)
def test_mean_radial_velocity_vs_r1a():
""" Compare <Vr> calculation to simple configuration
with exactly calculable result.
Here we verify that we get identical results when using the
``normalize_rbins_by`` feature with unit-normalization.
"""
npts = 10
xc1, yc1, zc1 = 0.1, 0.5, 0.5
xc2, yc2, zc2 = 0.05, 0.5, 0.5
sample1 = np.zeros((npts, 3)) + (xc1, yc1, zc1)
sample2 = np.zeros((npts, 3)) + (xc2, yc2, zc2)
vx1, vy1, vz1 = 0., 0., 0.
vx2, vy2, vz2 = 20., 0., 0.
velocities1 = np.zeros((npts, 3)) + (vx1, vy1, vz1)
velocities2 = np.zeros((npts, 3)) + (vx2, vy2, vz2)
normalize_rbins_by = np.ones(sample1.shape[0])
rbins = np.array([0, 0.1, 0.2, 0.3])
###########
# Run the test with PBCs turned off
result1 = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins, sample2=sample2, velocities2=velocities2)
result2 = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_normalized=rbins, normalize_rbins_by=normalize_rbins_by,
sample2=sample2, velocities2=velocities2)
assert np.allclose(result1, result2)
# Result should be identical with PBCs turned on
result1 = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins, sample2=sample2, velocities2=velocities2, period=1)
result2 = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_normalized=rbins, normalize_rbins_by=normalize_rbins_by,
sample2=sample2, velocities2=velocities2, period=1)
assert np.allclose(result1, result2)
def test_mean_radial_velocity_vs_r1b():
""" Compare <Vr> calculation to simple configuration
with exactly calculable result, explicitly testing
a nontrivial example of ``normalize_rbins_by`` feature
"""
npts = 10
xc1, yc1, zc1 = 0.2, 0.5, 0.5
xc2, yc2, zc2 = 0.05, 0.5, 0.5
sample1 = np.zeros((npts, 3)) + (xc1, yc1, zc1)
sample2 = np.zeros((npts, 3)) + (xc2, yc2, zc2)
vx1, vy1, vz1 = 0., 0., 0.
vx2, vy2, vz2 = 20., 0., 0.
velocities1 = np.zeros((npts, 3)) + (vx1, vy1, vz1)
velocities2 = np.zeros((npts, 3)) + (vx2, vy2, vz2)
normalize_rbins_by = np.zeros(sample1.shape[0]) + 0.1
rbins_normalized = np.array((0., 1., 2.))
###########
# Run the test with PBCs turned off
result = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_normalized=rbins_normalized, normalize_rbins_by=normalize_rbins_by,
sample2=sample2, velocities2=velocities2)
assert np.allclose(result, [0, -20]), "normalize_rbins_by feature is not implemented correctly"
def test_rvir_normalization_feature():
""" Test the rvir normalization feature. Lay down a regular grid of sample1 points.
Generate a sample2 point for each point in sample1, at a z value equal to 2.5*Rvir,
where Rvir is close to 0.01 for every point. Assign the same z-velocity to each sample2 point.
This allows the value of <Vr> to be calculated simply from <Vz>.
"""
sample1 = generate_3d_regular_mesh(5)
velocities1 = np.zeros_like(sample1)
rvir = 0.01
sample2 = np.copy(sample1)
sample2[:, 2] += 2.5*rvir
velocities2 = np.zeros_like(sample2)
velocities2[:, 2] = -43.
normalize_rbins_by = np.random.uniform(0.95*rvir, 1.05*rvir, sample1.shape[0])
rbins_normalized = np.array((0., 1., 2., 3., 4.))
result = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_normalized=rbins_normalized, normalize_rbins_by=normalize_rbins_by,
sample2=sample2, velocities2=velocities2)
correct_result = [0, 0, -43, 0]
assert np.allclose(result, correct_result)
def test_mean_radial_velocity_vs_r2b():
""" Compare <Vr> calculation to simple configuration
with exactly calculable result
"""
npts = 10
xc1, yc1, zc1 = 0.05, 0.5, 0.5
xc2, yc2, zc2 = 0.95, 0.5, 0.5
sample1 = np.zeros((npts, 3)) + (xc1, yc1, zc1)
sample2 = np.zeros((npts, 3)) + (xc2, yc2, zc2)
vx1, vy1, vz1 = 0., 0., 0.
vx2, vy2, vz2 = 20., 0., 0.
velocities1 = np.zeros((npts, 3)) + (vx1, vy1, vz1)
velocities2 = np.zeros((npts, 3)) + (vx2, vy2, vz2)
normalize_rbins_by = np.zeros(sample1.shape[0]) + 0.1
rbins_normalized = np.array((0., 1., 2.))
###########
# Run the test with PBCs turned off
result = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_normalized=rbins_normalized, normalize_rbins_by=normalize_rbins_by,
sample2=sample2, velocities2=velocities2)
assert np.allclose(result, [0, 0])
# Result should change with PBCs turned on
result = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_normalized=rbins_normalized, normalize_rbins_by=normalize_rbins_by,
sample2=sample2, velocities2=velocities2, period=1)
assert np.allclose(result, [0, -20])
def test_mean_radial_velocity_vs_r_correctness1():
""" This function tests that the
`~halotools.mock_observables.mean_radial_velocity_vs_r` function returns correct
results for a controlled distribution of points whose mean radial velocity
is analytically calculable.
For this test, the configuration is two tight localizations of points,
the first at (0.5, 0.5, 0.1), the second at (0.5, 0.5, 0.25).
The first set of points is moving at +50 in the z-direction;
the second set of points is at rest.
PBCs are set to infinity in this test.
So in this configuration, the two sets of points are moving towards each other,
and so the radial component of the relative velocity
should be -50 for cross-correlations in the radial separation bin containing the
pair of points. For any separation bin containing only
one set or the other, the auto-correlations should be 0 because each set of
points moves coherently.
The tests will be run with the two point configurations passed in as
separate ``sample1`` and ``sample2`` distributions, as well as bundled
together into the same distribution.
"""
correct_relative_velocity = -50
npts = 100
xc1, yc1, zc1 = 0.5, 0.5, 0.1
xc2, yc2, zc2 = 0.5, 0.5, 0.25
sample1 = generate_locus_of_3d_points(npts, xc=xc1, yc=yc1, zc=zc1, seed=fixed_seed)
sample2 = generate_locus_of_3d_points(npts, xc=xc2, yc=yc2, zc=zc2, seed=fixed_seed)
velocities1 = np.zeros(npts*3).reshape(npts, 3)
velocities2 = np.zeros(npts*3).reshape(npts, 3)
velocities1[:, 2] = 50.
rbins = np.array([0, 0.1, 0.3])
s1s2 = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins,
sample2=sample2, velocities2=velocities2)
assert np.allclose(s1s2[0], 0, rtol=0.01)
assert np.allclose(s1s2[1], correct_relative_velocity, rtol=0.01)
# Now bundle sample2 and sample1 together and only pass in the concatenated sample
sample = np.concatenate((sample1, sample2))
velocities = np.concatenate((velocities1, velocities2))
s1s1 = mean_radial_velocity_vs_r(sample, velocities, rbins_absolute=rbins)
assert np.allclose(s1s1[0], 0, rtol=0.01)
assert np.allclose(s1s1[1], correct_relative_velocity, rtol=0.01)
@pytest.mark.slow
def test_mean_radial_velocity_vs_r_correctness2():
""" This function tests that the
`~halotools.mock_observables.mean_radial_velocity_vs_r` function returns correct
results for a controlled distribution of points whose mean radial velocity
is analytically calculable.
For this test, the configuration is two tight localizations of points,
the first at (0.5, 0.5, 0.05), the second at (0.5, 0.5, 0.95).
The first set of points is moving at +50 in the z-direction;
the second set of points is at rest.
So in this configuration, when PBCs are operative
the two sets of points are moving away from each other,
and so the radial component of the relative velocity
should be +50 for cross-correlations in the radial separation bin containing the
pair of points. For any separation bin containing only
one set or the other, the auto-correlations should be 0 because each set of
points moves coherently.
When PBCs are turned off, the function should return zero as the points
are too distant to find pairs.
These tests will be applied with and without periodic boundary conditions.
The tests will also be run with the two point configurations passed in as
separate ``sample1`` and ``sample2`` distributions, as well as bundled
together into the same distribution.
"""
correct_relative_velocity = +50
npts = 100
xc1, yc1, zc1 = 0.5, 0.5, 0.05
xc2, yc2, zc2 = 0.5, 0.5, 0.9
sample1 = generate_locus_of_3d_points(npts, xc=xc1, yc=yc1, zc=zc1, seed=fixed_seed)
sample2 = generate_locus_of_3d_points(npts, xc=xc2, yc=yc2, zc=zc2, seed=fixed_seed)
velocities1 = np.zeros(npts*3).reshape(npts, 3)
velocities2 = np.zeros(npts*3).reshape(npts, 3)
velocities1[:, 2] = 50.
rbins = np.array([0, 0.1, 0.3])
# First run the calculation with PBCs set to unity
s1s2 = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins,
sample2=sample2, velocities2=velocities2, period=1)
assert np.allclose(s1s2[0], 0, rtol=0.01)
assert np.allclose(s1s2[1], correct_relative_velocity, rtol=0.01)
# Now set PBCs to infinity and verify that we instead get zeros
s1s2 = mean_radial_velocity_vs_r(sample1, velocities1,
rbins_absolute=rbins,
sample2=sample2, velocities2=velocities2)
assert np.allclose(s1s2[0], 0, rtol=0.01)
assert np.allclose(s1s2[1], 0, rtol=0.01)
# Bundle sample2 and sample1 together and only pass in the concatenated sample
sample = np.concatenate((sample1, sample2))
velocities = np.concatenate((velocities1, velocities2))
# Now repeat the above tests, with and without PBCs
s1s1 = mean_radial_velocity_vs_r(sample, velocities,
rbins_absolute=rbins, period=1)
assert np.allclose(s1s1[0], 0, rtol=0.01)
assert np.allclose(s1s1[1], correct_relative_velocity, rtol=0.01)
s1s1 = mean_radial_velocity_vs_r(sample, velocities, rbins_absolute=rbins)
assert np.allclose(s1s1[0], 0, rtol=0.01)
assert np.allclose(s1s1[1], 0, rtol=0.01)
def test_mean_radial_velocity_vs_r_correctness3():
""" This function tests that the
`~halotools.mock_observables.mean_radial_velocity_vs_r` function returns correct
results for a controlled distribution of points whose mean radial velocity
is analytically calculable.
For this test, the configuration is two tight localizations of points,
the first at (0.95, 0.5, 0.5), the second at (0.05, 0.5, 0.5).
The first set of points is moving at +50 in the x-direction;
the second set of points is moving at +25 in the x-direction.
So in this configuration, when PBCs are operative
the two sets of points are moving towards each other,
as the first set of points is "gaining ground" on the second set in the x-direction.
So the radial component of the relative velocity
should be -25 for cross-correlations in the radial separation bin containing the
pair of points. For any separation bin containing only
one set or the other, the auto-correlations should be 0 because each set of
points moves coherently.
When PBCs are turned off, the function should return zero as the points
are too distant to find pairs.
These tests will be applied with and without periodic boundary conditions.
The tests will also be run with the two point configurations passed in as
separate ``sample1`` and ``sample2`` distributions, as well as bundled
together into the same distribution.
"""
correct_relative_velocity = -25
npts = 100
xc1, yc1, zc1 = 0.95, 0.5, 0.5
xc2, yc2, zc2 = 0.05, 0.5, 0.5
sample1 = generate_locus_of_3d_points(npts, xc=xc1, yc=yc1, zc=zc1, seed=fixed_seed)
sample2 = generate_locus_of_3d_points(npts, xc=xc2, yc=yc2, zc=zc2, seed=fixed_seed)
velocities1 = np.zeros(npts*3).reshape(npts, 3)
velocities2 = np.zeros(npts*3).reshape(npts, 3)
velocities1[:, 0] = 50.
velocities2[:, 0] = 25.
rbins = np.array([0, 0.05, 0.3])
s1s2 = mean_radial_velocity_vs_r(sample1, velocities1, rbins,
sample2=sample2, velocities2=velocities2, period=1, approx_cell1_size=0.1)
assert np.allclose(s1s2[0], 0, rtol=0.01)
assert np.allclose(s1s2[1], correct_relative_velocity, rtol=0.01)
# repeat the test but with PBCs set to infinity
s1s2 = mean_radial_velocity_vs_r(sample1, velocities1, rbins,
sample2=sample2, velocities2=velocities2, approx_cell2_size=0.1)
assert np.allclose(s1s2[0], 0, rtol=0.01)
assert np.allclose(s1s2[1], 0, rtol=0.01)
# Now bundle sample2 and sample1 together and only pass in the concatenated sample
sample = np.concatenate((sample1, sample2))
velocities = np.concatenate((velocities1, velocities2))
# Repeat the above tests
s1s1 = mean_radial_velocity_vs_r(sample, velocities, rbins, period=1)
assert np.allclose(s1s1[0], 0, rtol=0.01)
assert np.allclose(s1s1[1], correct_relative_velocity, rtol=0.01)
s1s1 = mean_radial_velocity_vs_r(sample, velocities, rbins)
assert np.allclose(s1s1[0], 0, rtol=0.01)
assert np.allclose(s1s1[1], 0, rtol=0.01)
def test_mean_radial_velocity_vs_r_correctness4():
""" This function tests that the
`~halotools.mock_observables.mean_radial_velocity_vs_r` function returns correct
results for a controlled distribution of points whose mean radial velocity
is analytically calculable.
For this test, the configuration is two tight localizations of points,
the first at (0.5, 0.95, 0.5), the second at (0.5, 0.05, 0.5).
The first set of points is moving at -50 in the y-direction;
the second set of points is moving at +25 in the y-direction.
So in this configuration, when PBCs are operative
the two sets of points are each moving away from each other,
so the radial component of the relative velocity
should be +75 for cross-correlations in the radial separation bin containing the
pair of points. For any separation bin containing only
one set or the other, the auto-correlations should be 0 because each set of
points moves coherently.
When PBCs are turned off, the function should return zero as the points
are too distant to find pairs.
These tests will be applied with and without periodic boundary conditions.
The tests will also be run with the two point configurations passed in as
separate ``sample1`` and ``sample2`` distributions, as well as bundled
together into the same distribution.
"""
correct_relative_velocity = +75
npts = 100
xc1, yc1, zc1 = 0.5, 0.95, 0.5
xc2, yc2, zc2 = 0.5, 0.05, 0.5
sample1 = generate_locus_of_3d_points(npts, xc=xc1, yc=yc1, zc=zc1, seed=fixed_seed)
sample2 = generate_locus_of_3d_points(npts, xc=xc2, yc=yc2, zc=zc2, seed=fixed_seed)
velocities1 = np.zeros(npts*3).reshape(npts, 3)
velocities1[:, 1] = -50.
velocities2 = np.zeros(npts*3).reshape(npts, 3)
velocities2[:, 1] = 25.
rbins = np.array([0, 0.05, 0.3])
s1s2 = mean_radial_velocity_vs_r(sample1, velocities1, rbins,
sample2=sample2, velocities2=velocities2, period=1)
assert np.allclose(s1s2[0], 0, rtol=0.01)
assert np.allclose(s1s2[1], correct_relative_velocity, rtol=0.01)
# repeat the test but with PBCs set to infinity
s1s2 = mean_radial_velocity_vs_r(sample1, velocities1, rbins,
sample2=sample2, velocities2=velocities2)
assert np.allclose(s1s2[0], 0, rtol=0.01)
assert np.allclose(s1s2[1], 0, rtol=0.01)
# Now bundle sample2 and sample1 together and only pass in the concatenated sample
sample = np.concatenate((sample1, sample2))
velocities = np.concatenate((velocities1, velocities2))
# Repeat the above tests
s1s1 = mean_radial_velocity_vs_r(sample, velocities, rbins, period=1)
assert np.allclose(s1s1[0], 0, rtol=0.01)
assert np.allclose(s1s1[1], correct_relative_velocity, rtol=0.01)
s1s1 = mean_radial_velocity_vs_r(sample, velocities, rbins)
assert np.allclose(s1s1[0], 0, rtol=0.01)
assert np.allclose(s1s1[1], 0, rtol=0.01)
def test_mean_radial_velocity_vs_r_correctness5():
""" This function tests that the
`~halotools.mock_observables.mean_radial_velocity_vs_r` function returns correct
results for a controlled distribution of points whose mean radial velocity
is analytically calculable.
For this test, the configuration is two tight localizations of points,
the first at (0.05, 0.05, 0.05), the second at (0.95, 0.95, 0.95).
The first set of points is moving at (+50, +50, +50);
the second set of points is moving at (-50, -50, -50).
So in this configuration, when PBCs are operative
the two sets of points are each moving towards each other,
so the radial component of the relative velocity
should be +100*sqrt(3) for cross-correlations in the radial separation bin containing the
pair of points. For any separation bin containing only
one set or the other, the auto-correlations should be 0 because each set of
points moves coherently.
When PBCs are turned off, the function should return zero as the points
are too distant to find pairs.
These tests will be applied with and without periodic boundary conditions.
The tests will also be run with the two point configurations passed in as
separate ``sample1`` and ``sample2`` distributions, as well as bundled
together into the same distribution.
"""
correct_relative_velocity = np.sqrt(3)*100.
npts = 91
xc1, yc1, zc1 = 0.05, 0.05, 0.05
xc2, yc2, zc2 = 0.95, 0.95, 0.95
sample1 = generate_locus_of_3d_points(npts, xc=xc1, yc=yc1, zc=zc1, seed=fixed_seed)
sample2 = generate_locus_of_3d_points(npts, xc=xc2, yc=yc2, zc=zc2, seed=fixed_seed)
velocities1 = np.zeros(npts*3).reshape(npts, 3)
velocities2 = np.zeros(npts*3).reshape(npts, 3)
velocities1[:, :] = 50.
velocities2[:, :] = -50.
rbins = np.array([0, 0.1, 0.3])
s1s2 = mean_radial_velocity_vs_r(sample1, velocities1, rbins,
sample2=sample2, velocities2=velocities2, period=1)
assert np.allclose(s1s2[0], 0, rtol=0.01)
assert np.allclose(s1s2[1], correct_relative_velocity, rtol=0.01)
# repeat the test but with PBCs set to infinity
s1s2 = mean_radial_velocity_vs_r(sample1, velocities1, rbins,
sample2=sample2, velocities2=velocities2)
assert np.allclose(s1s2[0], 0, rtol=0.01)
assert np.allclose(s1s2[1], 0, rtol=0.01)
# Now bundle sample2 and sample1 together and only pass in the concatenated sample
sample = np.concatenate((sample1, sample2))
velocities = np.concatenate((velocities1, velocities2))
# Repeat the above tests
s1s1 = mean_radial_velocity_vs_r(sample, velocities, rbins, period=1)
assert np.allclose(s1s1[0], 0, rtol=0.01)
assert np.allclose(s1s1[1], correct_relative_velocity, rtol=0.01)
s1s1 = mean_radial_velocity_vs_r(sample, velocities, rbins)
assert np.allclose(s1s1[0], 0, rtol=0.01)
assert np.allclose(s1s1[1], 0, rtol=0.01)
@pytest.mark.slow
def test_mean_radial_velocity_vs_r_parallel1():
"""
Verify that the `~halotools.mock_observables.mean_radial_velocity_vs_r` function
returns identical results for two tight loci of points whether the function
runs in parallel or serial.
"""
npts = 91
xc1, yc1, zc1 = 0.5, 0.05, 0.05
xc2, yc2, zc2 = 0.45, 0.05, 0.1
sample1 = generate_locus_of_3d_points(npts, xc=xc1, yc=yc1, zc=zc1, seed=fixed_seed)
sample2 = generate_locus_of_3d_points(npts, xc=xc2, yc=yc2, zc=zc2, seed=fixed_seed)
velocities1 = np.zeros(npts*3).reshape(npts, 3)
velocities2 = np.zeros(npts*3).reshape(npts, 3)
velocities1[:, :] = 50.
velocities2[:, :] = 0.
rbins = np.array([0, 0.1, 0.3])
s1s2_parallel = mean_radial_velocity_vs_r(sample1, velocities1, rbins,
sample2=sample2, velocities2=velocities2, num_threads=3, period=1)
s1s2_serial = mean_radial_velocity_vs_r(sample1, velocities1, rbins,
sample2=sample2, velocities2=velocities2, num_threads=1, period=1)
assert np.all(s1s2_serial == s1s2_parallel)
@pytest.mark.slow
def test_mean_radial_velocity_vs_r_parallel2():
"""
Verify that the `~halotools.mock_observables.mean_radial_velocity_vs_r` function
returns identical results for two random distributions of points whether the function
runs in parallel or serial, with PBCs operative.
"""
npts = 101
with NumpyRNGContext(fixed_seed):
sample1 = np.random.random((npts, 3))
velocities1 = np.random.normal(loc=0, scale=100, size=npts*3).reshape((npts, 3))
sample2 = np.random.random((npts, 3))
velocities2 = np.random.normal(loc=0, scale=100, size=npts*3).reshape((npts, 3))
rbins = np.array([0, 0.1, 0.3])
s1s2_parallel = mean_radial_velocity_vs_r(sample1, velocities1, rbins,
sample2=sample2, velocities2=velocities2, num_threads=2, period=1)
s1s2_serial = mean_radial_velocity_vs_r(sample1, velocities1, rbins,
sample2=sample2, velocities2=velocities2, num_threads=1, period=1)
assert np.allclose(s1s2_serial, s1s2_parallel, rtol=0.001)
@pytest.mark.slow
def test_mean_radial_velocity_vs_r_parallel3():
"""
Verify that the `~halotools.mock_observables.mean_radial_velocity_vs_r` function
returns identical results for two random distributions of points whether the function
runs in parallel or serial, with PBCs turned off.
"""
npts = 101
with NumpyRNGContext(fixed_seed):
sample1 = np.random.random((npts, 3))
velocities1 = np.random.normal(loc=0, scale=100, size=npts*3).reshape((npts, 3))
sample2 = np.random.random((npts, 3))
velocities2 = np.random.normal(loc=0, scale=100, size=npts*3).reshape((npts, 3))
rbins = | np.array([0, 0.1, 0.3]) | numpy.array |
import tensorflow as tf
import numpy as np
from scipy.interpolate import interp1d
def weight_variable(shape, name=None):
return tf.get_variable(name=name, shape=shape, dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.001))
def bias_variable(shape, name=None):
return tf.get_variable(name=name, shape=shape, dtype=tf.float32, initializer=tf.constant_initializer(0))
def conv2d(x, w, strides=1, name=None):
return tf.nn.conv2d(x, w, strides=[1, 1, strides, 1], padding="SAME", name=name)
def lrelu(x, leak=0.2):
return tf.maximum(x, leak*x)
def prelu(x, scope=None):
"""parametric ReLU activation"""
with tf.variable_scope(name_or_scope=scope, default_name="prelu"):
_alpha = tf.get_variable("prelu", shape=1,
dtype=x.dtype, initializer=tf.constant_initializer(0.1))
return tf.maximum(0.0, x) + _alpha * tf.minimum(0.0, x), _alpha
def deconv(x, w, output_shape, strides, name=None):
dyn_input_shape = tf.shape(x)
batch_size = dyn_input_shape[0]
output_shape = tf.stack([batch_size, output_shape[1], output_shape[2], output_shape[3]])
output = tf.nn.conv2d_transpose(x, w, output_shape, strides, padding="SAME", name=name)
return output
def prefilter(k_size, channel_in, channel_out, name=None):
x = np.linspace(0, 80, num=k_size)
filters = np.zeros([k_size, 1])
filters[int((k_size - 1) / 2), 0] = 1
for chn in range(channel_out - 1):
y = np.exp(-np.square(x - 40) / (200 / ((channel_out - 1) * 5 + 1) * (chn * 5 + 1)))
value = interp1d(x, y, kind='cubic')
value = value(x)
value = value / np.sum(value)
filters = np.concatenate((filters, np.expand_dims(value, axis=1)), axis=1)
filters = np.tile(filters, [1, channel_in, 1, 1])
filters = np.transpose(filters, (0, 2, 1, 3))
return tf.get_variable(name=name, shape=[1, k_size, channel_in, channel_out], dtype=tf.float32, initializer=tf.constant_initializer(filters))
def shear(x, scale):
global y
input_shape = x.get_shape().as_list()
hei = input_shape[1]
wid = input_shape[2]
shift_max = np.ceil((hei - 1) / 2 * abs(scale))
base_shift = shift_max - (hei - 1) / 2 * abs(scale)
paddings = [[0, 0], [0, 0], [int(shift_max), int(shift_max)], [0, 0]]
x = tf.pad(x, paddings)
for i in range(hei):
if scale > 0:
shift = i * scale + base_shift
else:
shift = (hei - i - 1) * abs(scale) + base_shift
if shift == int(shift):
cur_y = tf.slice(x, [0, i, int(shift), 0], [-1, 1, wid, -1])
else:
cur_y = tf.add((shift - | np.floor(shift) | numpy.floor |
# -*- coding: utf-8 -*-
# Copyright (C) 2022 Machine Learning Group of the University of Oldenburg.
# Licensed under the Academic Free License version 3.0
from __future__ import division, print_function
import os
import re
import glob
import numpy as np
from matplotlib.ticker import MaxNLocator
from utils import eval_fn
import matplotlib
matplotlib.use("agg")
import matplotlib.pyplot as plt # noqa
from tvutil.viz import make_grid_with_black_boxes_and_white_background, scale # noqa
class Visualizer(object):
def __init__(
self,
viz_every,
output_directory,
clean_image,
noisy_image,
patch_size=None,
ncol_gfs=5,
sort_gfs=True,
topk_gfs=None,
cmap=None,
figsize=[9, 3],
positions={
"clean": [0.001, 0.01, 0.20, 0.85],
"noisy": [0.218, 0.01, 0.20, 0.85],
"rec": [0.433, 0.01, 0.20, 0.85],
"gfs": [0.715, 0.37, 0.28, 0.56],
"pies": [0.731, 0.18, 0.26, 0.24],
},
labelsize=10,
gif_framerate=None,
):
self._viz_every = viz_every
self._output_directory = output_directory
self._gif_framerate = gif_framerate
if gif_framerate is not None and viz_every > 1:
print("Choose --viz_every=1 for best gif results")
self._clean_image = clean_image
self._noisy_image = noisy_image
self._patch_size = patch_size
self._ncol_gfs = ncol_gfs
self._sort_gfs = sort_gfs
if sort_gfs:
print(
"Displayed GFs will be ordered according to prior activation (from highest "
"to lowest)"
)
self._topk_gfs = topk_gfs
self._isrgb = np.ndim(clean_image) == 3
self._cmap = (plt.cm.jet if self._isrgb else plt.cm.gray) if cmap is None else cmap
self._positions = positions
self._labelsize = labelsize
self._fig = plt.figure(figsize=figsize)
self._axes = {k: self._fig.add_axes(v, xmargin=0, ymargin=0) for k, v in positions.items()}
self._handles = {k: None for k in positions}
self._viz_clean()
self._viz_noisy()
def _viz_clean(self):
assert "clean" in self._axes
ax = self._axes["clean"]
clean = scale(self._clean_image, [0.0, 1.0]) if self._isrgb else self._clean_image
self._handles["clean"] = ax.imshow(clean)
ax.axis("off")
self._handles["clean"].set_cmap(self._cmap)
ax.set_title("Clean\n")
def _viz_noisy(self):
assert "noisy" in self._axes
ax = self._axes["noisy"]
noisy = self._noisy_image
psnr_noisy = eval_fn(self._clean_image, noisy)
print("psnr of noisy = {:.2f}".format(psnr_noisy))
noisy = scale(noisy, [0.0, 1.0]) if self._isrgb else noisy
self._handles["noisy"] = ax.imshow(noisy)
ax.axis("off")
self._handles["noisy"].set_cmap(self._cmap)
ax.set_title("Noisy\nPSNR={:.2f})".format(psnr_noisy))
def _viz_rec(self, epoch, rec):
assert "rec" in self._axes
ax = self._axes["rec"]
rec = scale(rec, [0.0, 1.0]) if self._isrgb else rec
if self._handles["rec"] is None:
self._handles["rec"] = ax.imshow(rec)
ax.axis("off")
else:
self._handles["rec"].set_data(rec)
self._handles["rec"].set_cmap(self._cmap)
self._handles["rec"].set_clim(vmin=np.min(rec), vmax=np.max(rec))
psnr = eval_fn(self._clean_image, rec)
ax.set_title("Reco @ {}\n(PSNR={:.2f})".format(epoch, psnr))
def _viz_weights(self, epoch, gfs, suffix=""):
assert "gfs" in self._axes
ax = self._axes["gfs"]
D, H = gfs.shape
no_channels = 3 if self._isrgb else 1
patch_height, patch_width = (
(int(np.sqrt(D / no_channels)), int(np.sqrt(D / no_channels)))
if self._patch_size is None
else self._patch_size
)
grid, cmap, vmin, vmax, scale_suff = make_grid_with_black_boxes_and_white_background(
images=gfs.T.reshape(H, no_channels, patch_height, patch_width),
nrow=int(np.ceil(H / self._ncol_gfs)),
surrounding=2,
padding=4,
repeat=10,
global_clim=False,
sym_clim=False,
cmap=self._cmap,
eps=0.02,
)
gfs = grid.transpose(1, 2, 0) if self._isrgb else | np.squeeze(grid) | numpy.squeeze |
import numpy as np
from sklearn.preprocessing import LabelBinarizer
import svm
def sigmoid(x): #激活函数
return 1/(1+np.exp(-x))
def dsigmoid(x): #激活函数的导数
return x*(1-x)
class NeuralNetwork:
def __init__(self,layers):
# 权重初始化,最后一列为偏置值
self.V = np.random.random((layers[0] + 1, layers[1]+1))*2 - 1
self.W = | np.random.random((layers[1] + 1, layers[2])) | numpy.random.random |
#ISTA(Iterative Shrinkage Thresholding Algorithm)
#L1 minimization ||Ax-b||_2^2 + lambda * ||x||_1
import numpy as np #import numpy
import matplotlib.pyplot as plt
from numpy import linalg as LA
def threshold(x,lamb,C):
if x < -lamb/2/C:
gamma_x = x + lamb/2/C
elif x > lamb/2/C:
gamma_x = x - lamb/2/C
else:
gamma_x = 0
return gamma_x
def shrinkage(x,a): #x: vector , a: scalar
new_z = np.zeros(len(x))
norm_x = LA.norm(x)
if norm_x - a/2 < 0:
pass
else:
new_z = (1-a/2/norm_x)*x
return new_z
def ISTA_1(A,x,b,lamb,C, tol,threshold): #solve a system Ax = b with L1-regularizer
d = 100000
iter = 0
energy = np.zeros(50000)
x_new = np.zeros(np.shape(A)[1])
# while (d > tol):
while(iter<20000):
y = x + 1/C* np.dot( | np.transpose(A) | numpy.transpose |
"""
MAPSCI: Multipole Approach of Predicting and Scaling Cross Interactions
Handles the primary functions
"""
import numpy as np
import scipy.optimize as spo
import logging
logger = logging.getLogger(__name__)
def calc_distance_array(bead_dict, tol=0.01, max_factor=2, lower_bound="rmin"):
r"""
Calculation of array for nondimensionalized distance array.
Nondimensional parameters are scaled using the following physical constants: vacuum permittivity, :math:`\varepsilon_{0}`, Boltzmann constant, :math:`k_{B}`, and elementary charge, :math:`e`.
Parameters
----------
bead_dict : dict
Dictionary of multipole parameters.
- sigma (float) Nondimensionalized size parameter, :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
tol : float, Optional, default=0.01
Ratio of absolute value of repulsive term over attractive term of the Mie potential to define minimum bound
max_factor : int, Optional, default=2
Factor to multiply minimum bound by to define maximum bound.
lower_bound : str, Optional, default='rmin'
Lower bound of distance array. Can be one of:
- rmin: the position of the potential well
- sigma: the size parameter
- tolerance: Uses 'tol' keyword to define the ratio between the attractive and repulsive terms of the Mie potential, note that if tol = 0.01 the lower bound will be ~2.5*sigma.
Returns
-------
r : numpy.ndarray
Array (or float) in [Å] or nondimensionalized, distance between two beads. :math:`r'=r (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
"""
if lower_bound == "rmin":
rm = mie_potential_minimum(bead_dict)
elif lower_bound == "sigma":
rm = bead_dict["sigma"]
elif lower_bound == "tolerance":
rm = bead_dict["sigma"] * (1 / tol)**(1 / (bead_dict["lambdar"] - bead_dict["lambdaa"]))
else:
raise ValueError("Method, {}, is not supported to calculating lower_bound of fitting/integration".format(lower_bound))
r_array = np.linspace(rm, max_factor * rm, num=10000)
return r_array
def mie_potential_minimum(bead_dict):
r"""
Calculate Mie potential minimum of potential well.
Nondimensional parameters are scaled using the following physical constants: vacuum permittivity, :math:`\varepsilon_{0}`, Boltzmann constant, :math:`k_{B}`, and elementary charge, :math:`e`.
Parameters
----------
bead_dict : dict
Dictionary of multipole parameters.
- sigma (float) Size parameter in [Å] or nondimensionalized as :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
Returns
-------
rmin : float
Position of minimum of potential well
"""
return bead_dict["sigma"] * (bead_dict["lambdar"] / bead_dict["lambdaa"])**(1 / (bead_dict["lambdar"] - bead_dict["lambdaa"]))
def mie_combining_rules(bead1, bead2):
r"""
Calculate basic mixed parameters, where the energy parameter is calculated with the geometric mean
Nondimensional parameters are scaled using the following physical constants: vacuum permittivity, :math:`\varepsilon_{0}`, Boltzmann constant, :math:`k_{B}`, and elementary charge, :math:`e`.
Parameters
----------
beadA : dict
Dictionary of multipole parameters for bead_A.
- epsilon (float) Energy parameter scaled by :math:`k_{B}` in [K], or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
- sigma (float) Size parameter in [Å], or nondimensionalized as :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
beadB : dict
Dictionary of multipole parameters for bead_B.
- epsilon (float) Energy parameter scaled by :math:`k_{B}` in [K], or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
- sigma (float) Size parameter in [Å], or nondimensionalized as :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
Returns
-------
beadAB : dict
Dictionary of multipole parameters for bead_B.
- epsilon (float) Energy parameter scaled by :math:`k_{B}` in [K], or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
- sigma (float) Size parameter in [Å], or nondimensionalized as :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
"""
beadAB = {}
beadAB["sigma"] = (bead1["sigma"] + bead2["sigma"]) / 2
beadAB["lambdar"] = 3 + np.sqrt((bead1["lambdar"] - 3) * (bead2["lambdar"] - 3))
beadAB["lambdaa"] = 3 + np.sqrt((bead1["lambdaa"] - 3) * (bead2["lambdaa"] - 3))
beadAB["epsilon"] = np.sqrt(bead1["epsilon"] * bead2["epsilon"])
return beadAB
def calc_mie_attractive_potential(r, bead_dict, shape_factor_scale=False):
r"""
Calculation of attractive Mie potential.
Nondimensional parameters are scaled using the following physical constants: vacuum permittivity, :math:`\varepsilon_{0}`, Boltzmann constant, :math:`k_{B}`, and elementary charge, :math:`e`.
Parameters
----------
r : numpy.ndarray
Array (or float) in either [Å] or nondimensionalized distance between two beads. :math:`r'=r (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`, whatever is consistent with 'bead_dict'
bead_dict : dict
Dictionary of multipole parameters for bead_A.
- epsilon (float) Energy parameter scaled by :math:`k_{B}` in [K], or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
- sigma (float) Size parameter in [Å], or nondimensionalized as :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
- Sk (float) Shape factor
shape_factor_scale : bool, Optional, default=False
Scale energy parameter based on shape factor epsilon*Si*Sj
Returns
-------
potential : numpy.ndarray
Array of nondimensionalized potential between beads from Mie potential. Array is equal in length to "r". :math:`\phi'=\phi/(3k_{B}T)`
"""
if shape_factor_scale:
if "Sk" in bead_dict:
bead_dict["epsilon"] = bead_dict["epsilon"] * bead_dict["Sk"]**2
else:
raise ValueError("Shape factor was not provided in bead dictionary")
potential = -prefactor(bead_dict["lambdar"], bead_dict["lambdaa"]) * bead_dict["epsilon"] * (bead_dict["sigma"] /
r)**bead_dict["lambdaa"]
return potential
def calc_mie_repulsive_potential(r, bead_dict, shape_factor_scale=False):
r"""
Calculation of repulsive Mie potential.
Nondimensional parameters are scaled using the following physical constants: vacuum permittivity, :math:`\varepsilon_{0}`, Boltzmann constant, :math:`k_{B}`, and elementary charge, :math:`e`.
Parameters
----------
r : numpy.ndarray
Array (or float) in either [Å] or nondimensionalized distance between two beads. :math:`r'=r (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`, whatever is consistent with 'bead_dict'
bead_dict : dict
Dictionary of multipole parameters for bead_A.
- epsilon (float) Energy parameter scaled by :math:`k_{B}` in [K], or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
- sigma (float) Size parameter in [Å], or nondimensionalized as :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
- Sk (float) Shape factor
shape_factor_scale : bool, Optional, default=False
Scale energy parameter based on shape factor epsilon*Si*Sj
Returns
-------
potential : numpy.ndarray
Array of nondimensionalized potential between beads from Mie potential. Array is equal in length to "r". :math:`\phi'=\phi/(3k_{B}T)`
"""
if shape_factor_scale:
if "Sk" in bead_dict:
bead_dict["epsilon"] = bead_dict["epsilon"] * bead_dict["Sk"]**2
else:
raise ValueError("Shape factor was not provided in bead dictionary")
potential = prefactor(bead_dict["lambdar"], bead_dict["lambdaa"]) * bead_dict["epsilon"] * (bead_dict["sigma"] /
r)**bead_dict["lambdar"]
return potential
def prefactor(lamr, lama):
""" Calculation prefactor for Mie potential: :math:`C_{Mie}=\lambda_r/(\lambda_r-\lambda_a) (\lambda_r/\lambda_a)^{\lambda_a/(\lambda_r-\lambda_a)}`
"""
return lamr / (lamr - lama) * (lamr / lama)**(lama / (lamr - lama))
def calc_lambdaij_from_epsilonij(epsij, bead1, bead2):
r"""
Calculates cross-interaction exponents from cross interaction energy parameter
Nondimensional parameters are scaled using the following physical constants: vacuum permittivity, :math:`\varepsilon_{0}`, Boltzmann constant, :math:`k_{B}`, and elementary charge, :math:`e`.
Parameters
----------
epsilonij : float
Fit energy parameter in [K] or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
beadA : dict
Dictionary of multipole parameters for bead_A.
- epsilon (float) Energy parameter scaled by :math:`k_{B}` in [K], or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
- sigma (float) Size parameter in [Å], or nondimensionalized as :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
- Sk (float) Shape factor
beadB : dict
Dictionary of multipole parameters for bead_B.
- epsilon (float) Energy parameter scaled by :math:`k_{B}` in [K], or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
- sigma (float) Size parameter in [Å], or nondimensionalized as :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
- Sk (float) Shape factor
Returns
-------
lambdar_new : float
Repulsive exponent
lambdaa_new : float
Attractive exponent
"""
sigmaij = np.mean([bead1["sigma"], bead2["sigma"]])
tmp = epsij * sigmaij**3 / np.sqrt(bead1["sigma"]**3 * bead2["sigma"]**3) / np.sqrt(
bead1["epsilon"] * bead2["epsilon"])
lamr_ij = 3 + tmp * np.sqrt((bead1["lambdar"] - 3) * (bead2["lambdar"] - 3))
lama_ij = 3 + tmp * np.sqrt((bead1["lambdaa"] - 3) * (bead2["lambdaa"] - 3))
return lamr_ij, lama_ij
def calc_epsilonij_from_lambda_aij(lambda_a, bead1, bead2):
r"""
Calculate cross-interaction energy parameter from self-interaction parameters and cross-interaction attractive exponent using from scaling with vdW attraction parameter
Nondimensional parameters are scaled using the following physical constants: vacuum permittivity, :math:`\varepsilon_{0}`, Boltzmann constant, :math:`k_{B}`, and elementary charge, :math:`e`.
Parameters
----------
lambda_aij : float
Mixed attractive exponent from multipole combining rules
beadA : dict
Dictionary of multipole parameters for bead_A.
- epsilon (float) Energy parameter scaled by :math:`k_{B}` in [K], or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
- sigma (float) Size parameter in [Å], or nondimensionalized as :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
- Sk (float) Shape factor
beadB : dict
Dictionary of multipole parameters for bead_B.
- epsilon (float) Energy parameter scaled by :math:`k_{B}` in [K], or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
- sigma (float) Size parameter in [Å], or nondimensionalized as :math:`\sigma'=\sigma (4 \pi \varepsilon_{0}) 3k_{B}T e^{-2}`
- lambdar (float) Repulsive exponent
- lambdaa (float) Attractive exponent
- Sk (float) Shape factor
Returns
-------
epsilon_ij : float
Energy parameter scaled by :math:`k_{B}` in [K], or nondimensionalized as :math:`\epsilon'=\epsilon/(3k_{B}T)`
"""
tmp_sigma = np.sqrt(bead1["sigma"]**3 * bead2["sigma"]**3) / np.mean([bead1["sigma"], bead2["sigma"]])**3
tmp_lambda = (lambda_a - 3) / | np.sqrt((bead1["lambdaa"] - 3) * (bead2["lambdaa"] - 3)) | numpy.sqrt |
"""
In this script we have functions that calculate the spectral norm for different keras layers.
Specifically we can calculate the spectral norm of
1) convolutional
2) locally connected layers
. This is a difficult problem as the full operators are huge sparse matrices.
"""
import numpy as np
from keras.callbacks import Callback
def compute_spectral_norm_of_conv(weights,featuremap_dim):
# The dimensions of the weight matrix are
# trainable_weights[0] = (filter_d1,filter_d2,input_channels,output_channels) This is the kernel.
# trainable_weights[1] = (output_channels) This is the bias.
dim1 = weights.shape[0]
dim2 = weights.shape[1]
dim3 = weights.shape[2]
dim4 = weights.shape[3]
fourier_weights = np.empty((featuremap_dim*featuremap_dim,dim3,dim4),dtype='cfloat')
tmp_featuremap = np.zeros((featuremap_dim,featuremap_dim))
for i in range(0,dim3):
for j in range(0,dim4):
tmp_featuremap[0:dim1,0:dim2] = weights[:,:,i,j]
fourier_weights[:,i,j] = np.reshape(np.fft.fft2(tmp_featuremap),-1)
max_l2 = 0
for i in range(0,featuremap_dim*featuremap_dim):
if np.linalg.norm(fourier_weights[i,:,:],2)>max_l2:
max_l2 = | np.linalg.norm(fourier_weights[i,:,:],2) | numpy.linalg.norm |
# encoding=utf8
# pylint: disable=mixed-indentation, multiple-statements, line-too-long, unused-argument, no-self-use, no-self-use, attribute-defined-outside-init, logging-not-lazy, len-as-condition, singleton-comparison, arguments-differ, redefined-builtin, bad-continuation
import logging
from numpy import apply_along_axis, asarray, inf, argmin, argmax, sum, full
from NiaPy.algorithms.algorithm import Algorithm
__all__ = ['GravitationalSearchAlgorithm']
logging.basicConfig()
logger = logging.getLogger('NiaPy.algorithms.basic')
logger.setLevel('INFO')
class GravitationalSearchAlgorithm(Algorithm):
r"""Implementation of gravitational search algorithm.
**Algorithm:** Gravitational Search Algorithm
**Date:** 2018
**Author:** <NAME>
**License:** MIT
**Reference URL:** https://doi.org/10.1016/j.ins.2009.03.004
**Reference paper:** <NAME>, <NAME>, <NAME>, GSA: A Gravitational Search Algorithm, Information Sciences, Volume 179, Issue 13, 2009, Pages 2232-2248, ISSN 0020-0255
"""
Name = ['GravitationalSearchAlgorithm', 'GSA']
@staticmethod
def typeParameters(): return {
'NP': lambda x: isinstance(x, int) and x > 0,
'G_0': lambda x: isinstance(x, (int, float)) and x >= 0,
'epsilon': lambda x: isinstance(x, float) and 0 < x < 1
}
def setParameters(self, NP=40, G_0=2.467, epsilon=1e-17, **ukwargs):
r"""Set the algorithm parameters.
**Arguments:**
NP {integer} -- number of planets in population
G_0 {real} -- starting gravitational constant
"""
self.NP, self.G_0, self.epsilon = NP, G_0, epsilon
if ukwargs: logger.info('Unused arguments: %s' % (ukwargs))
def G(self, t): return self.G_0 / t
def d(self, x, y, ln=2): return sum((x - y) ** ln) ** (1 / ln)
def runTask(self, task):
X, v = self.uniform(task.Lower, task.Upper, [self.NP, task.D]), full([self.NP, task.D], 0.0)
xb, xb_f = None, task.optType.value * inf
while not task.stopCondI():
X_f = apply_along_axis(task.eval, 1, X)
ib, iw = argmin(X_f), argmax(X_f)
if xb_f > X_f[ib]: xb, xb_f = X[ib], X_f[ib]
m = (X_f - X_f[iw]) / (X_f[ib] - X_f[iw])
M = m / sum(m)
Fi = asarray([[self.G(task.Iters) * ((M[i] * M[j]) / (self.d(X[i], X[j]) + self.epsilon)) * (X[j] - X[i]) for j in range(len(M))] for i in range(len(M))])
F = sum(self.rand([self.NP, task.D]) * Fi, axis=1)
a = F.T / (M + self.epsilon)
v = self.rand([self.NP, task.D]) * v + a.T
X = | apply_along_axis(task.repair, 1, X + v, self.Rand) | numpy.apply_along_axis |
'''
Pre-process the data to extract patches
Input: A csv file containing path to input files
'''
import argparse
import os
import sys
import math
import numpy as np
import SimpleITK as sitk
import pandas as pd
import multiprocessing as mp
lowerThreshold = -1024
upperThreshold = 240
def convert_to_isotropic(inputVolume, isoSpacing=1.0):
inputSpacing = inputVolume.GetSpacing()
inputSize = inputVolume.GetSize()
#Resample the images to make them iso-tropic
resampleFilter = sitk.ResampleImageFilter()
T = sitk.Transform()
T.SetIdentity()
resampleFilter.SetTransform(T)
resampleFilter.SetInterpolator(sitk.sitkBSpline)
resampleFilter.SetDefaultPixelValue(float(-1024))
# isoSpacing = 1 #math.sqrt(inputSpacing[2] * inputSpacing[0])
resampleFilter.SetOutputSpacing((isoSpacing,isoSpacing,isoSpacing))
resampleFilter.SetOutputOrigin(inputVolume.GetOrigin())
resampleFilter.SetOutputDirection(inputVolume.GetDirection())
dx = int(inputSize[0] * inputSpacing[0] / isoSpacing)
dy = int(inputSize[1] * inputSpacing[1] / isoSpacing)
dz = int((inputSize[2] - 1 ) * inputSpacing[2] / isoSpacing)
resampleFilter.SetSize((dx,dy,dz))
try:
resampleVolume = resampleFilter.Execute(inputVolume)
except Error as err:
print("Resample failed: " + str(imageFilePath) )
print(err.decode(encoding='UTF-8'))
return None
return resampleVolume
def pad_img(input_img, image_lowest_intensity=-1024):
lower_bound = [30] * 3
upper_bound = [30] * 3
cpf = sitk.ConstantPadImageFilter()
cpf.SetConstant(image_lowest_intensity)
cpf.SetPadLowerBound(lower_bound)
cpf.SetPadUpperBound(upper_bound)
input_img = cpf.Execute(input_img)
return input_img
def Image2Patch(inputImg, step_size, patch_size, registered_patch_loc):
""" This function converts image to patches.
Here is the input of the function:
inputImg : input image. This should be simpleITK object
patchSize : size of the patch. It should be array of three scalar
Here is the output of the function:
patchImgData : It is a list containing the patches of the image
patchLblData : Is is a list containing the patches of the label image
"""
patch_vol = patch_size[0]*patch_size[1]*patch_size[2]
patch_img_data = []
patch_loc = []
for i in range(registered_patch_loc.shape[0]):
x, y, z = registered_patch_loc[i].tolist()
#print(x,y,z)
patchImg = sitk.RegionOfInterest(inputImg, size=patch_size, index=[x,y,z])
npLargePatchImg = sitk.GetArrayFromImage(patchImg)
patch_img_data.append(npLargePatchImg.copy())
patch_loc.append([x, y, z])
patch_img_data = np.asarray(patch_img_data)
patch_loc = np.asarray(patch_loc)
return patch_img_data, patch_loc
def extract_patch(isoRawImage_file, altas_patch_loc):
#Read the input isotropic image volume
isoRawImage = sitk.ReadImage(isoRawImage_file)
isoRawImage = convert_to_isotropic(isoRawImage)
isoRawImage = pad_img(isoRawImage)
npIsoRawImage = sitk.GetArrayFromImage(isoRawImage)
#print(npIsoRawImage.shape)
# Thresholding the isotropic raw image
npIsoRawImage[npIsoRawImage > upperThreshold] = upperThreshold
npIsoRawImage[npIsoRawImage < lowerThreshold] = lowerThreshold
thresholdIsoRawImage = sitk.GetImageFromArray(npIsoRawImage)
thresholdIsoRawImage.SetOrigin(isoRawImage.GetOrigin())
thresholdIsoRawImage.SetSpacing(isoRawImage.GetSpacing())
thresholdIsoRawImage.SetDirection(isoRawImage.GetDirection())
# Prepare registered patch location
registered_patch_loc = []
affine_trans=sitk.ReadTransform("./INSP2Atlas/transform/"\
+ isoRawImage_file.split('/')[-1][:-7]+"_Reg_Atlas_Affine_0GenericAffine.mat")
for i in range(altas_patch_loc.shape[0]):
physical_cor_on_fixed = tuple(altas_patch_loc[i])
physical_cor_on_moving = affine_trans.TransformPoint(physical_cor_on_fixed)
index_on_moving = isoRawImage.TransformPhysicalPointToIndex(physical_cor_on_moving)
registered_patch_loc.append(list(index_on_moving))
registered_patch_loc = np.array(registered_patch_loc)
#Extract Patches
# Generate Patches of the masked Image
patchImgData, patch_loc = Image2Patch(thresholdIsoRawImage, \
[step_size]*3, [patch_size]*3, registered_patch_loc)
return patchImgData, patch_loc
def prep_adjacency_matrix(patch_loc):
adj = []
for i in range(patch_loc.shape[0]):
adj_row = np.zeros((patch_loc.shape[0],))
dist = np.abs(patch_loc - patch_loc[i])
max_side_dist = dist.max(1)
dist = dist[max_side_dist<patch_size,:]
volume = np.abs(dist-patch_size)
volume = volume[:,0] * volume[:,1] * volume[:,2]
#print(volume.shape)
#print(adj_row[max_side_dist<patch_size].shape)
adj_row[max_side_dist<patch_size] = volume / (patch_size**3)
adj.append(adj_row.transpose())
adj = np.asarray(adj)
#adj = (adj / np.sum(adj, 0)).transpose()
return adj
def run(start, end, batch_index):
df = pd.read_csv(input_csv)
df = df[~df['image'].isnull()]
# Prepare physical coord of patch location
fixed_img = sitk.ReadImage(atlas_image)
altas_patch_loc_temp=[]
for i in range(altas_patch_loc.shape[0]):
altas_patch_loc_temp.append(list(fixed_img.TransformIndexToPhysicalPoint(tuple(altas_patch_loc[i,:].tolist()))))
altas_patch_loc=np.array(altas_patch_loc_temp)
del altas_patch_loc_temp, fixed_img
for i in range(start,end):
row = df.iloc[i]
subject_id = row['sid']
#if subject_id != '19676E':
# continue
print(row['image'])
output_basename = row['image'].split('/')[-1][:-24]
isotropicFileName = "./INSP2Atlas/clamped/"+output_basename+".nii.gz"
patchFileName = os.path.join(output_dir, 'patch', output_basename+'_patch.npy')
if not os.path.exists(isotropicFileName):
print(output_basename, "image not found")
continue
if not os.path.exists("./INSP2Atlas/transform/"\
+ output_basename +"_Reg_Atlas_Affine_0GenericAffine.mat"):
print(output_basename, "mat not found")
continue
if os.path.getsize(isotropicFileName)/(1024.**2) < 16:
continue
if not os.path.exists(patchFileName):
try:
patchImgData, patch_loc = extract_patch(isotropicFileName, altas_patch_loc)
adj = prep_adjacency_matrix(patch_loc)
| np.save(patchFileName, patchImgData) | numpy.save |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Jan 17 09:39:23 2020
@author: u0101486
"""
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Dec 5 12:26:49 2019
@author: u0101486
"""
# Aggregate QC measures
import os
import sys
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import spearmanr
import configparser
config = configparser.ConfigParser()
config.read('/home/luna.kuleuven.be/u0101486/workspace/fmri_proc/params.ini')
#PATH to qclib
sys.path.append(config['PATHS']['QCLIB_PATH'])
sys.path.append('/home/luna.kuleuven.be/u0101486/workspace/fmri_proc/ext/nitransforms/nitransforms')
import qclib.common_funcs as gpc
import shutil
from warnings import filterwarnings
filterwarnings('ignore')
import pandas as pd
import statsmodels.formula.api as smf
import multiprocessing as mp
import time
from functools import partial
# ======================================================================
# ======================================================================
#project = 'CRUNCH'
#project = 'CAI_China'
project = 'RepImpact'
baseDir = '/home/luna.kuleuven.be/u0101486/workspace/data/' + project + '/tmp/'
qcDir = '/home/luna.kuleuven.be/u0101486/workspace/data/' + project + '/Quality_Control/FinalProc_20200714/Files/'
distMat = '/home/luna.kuleuven.be/u0101486/workspace/fmri_proc/atlas/CAT12/lg400_cobra_distance.txt'
distMat = np.loadtxt(distMat, delimiter=',')
distMat = distMat[0:400, 0:400]
nNodes = distMat.shape[0]
distVec = np.reshape(distMat, (1,nNodes*nNodes))
meanDt = np.mean(distVec)
stdDt = np.std(distVec)
distSort = np.argsort(distVec)
distThreshold = 0.1
i = 0
j = 1
while j < distVec.shape[1]:
dist = np.sqrt( (distVec[0,distSort[0,i]]-distVec[0,distSort[0,j]])**2)
if dist < distThreshold or dist == 0:
distVec[0,distSort[0,j]] = -100
else:
i = j
j += 1
#print( len(distVec[np.where(distVec > -100)]) )
#plt.plot(np.sort(distVec[np.where(distVec > -100)]), '.')
##%%
import nibabel as nib
atlas=nib.load('/home/luna.kuleuven.be/u0101486/workspace/fmri_proc/atlas/CAT12/lg400_cobra.nii')
atlas=atlas.get_fdata()
x,y,z=atlas.shape
atlas[np.where(np.isnan(atlas))]=0
uNodes=np.unique(atlas.reshape((x*y*z))).reshape([1,-1]).astype(int)
#statModels = ['NONE', 'SFIX', 'SFIX_D', 'SRP24WM1CSF1', 'SRP24CC', 'SRP9']
procBase = ['']
statModels = ['FAC_DiC_RP6', 'FAC_DiC_RP24', 'FAC', 'FAC_CC_RP24',
'FAC_RP24', 'FAC_WM_CSF', 'FAD_CC_RP24', 'FAD_DiC_RP24', 'RP24_WM_CSF']
statModels = ['FAC_CC_RP6', 'FAD_CC_RP6', 'FAC_DiC_RP6', 'FAD_DiC_RP6',
'FAC_CC_RP24', 'FAD_CC_RP24', 'FAC_DiC_RP24', 'FAD_DiC_RP24',
'FAC_WM_CSF_RP6', 'FAD_WM_CSF_RP24', 'RP24_WM_CSF', 'RP24_CC']
statModels= ['FAD_DiC_RP6', 'FAD_DiC_RP24', 'FAC_WM_CSF_RP6']
#statModels = [ 'FAC_DiC_RP24' ]
#if os.path.isdir(qcDir) == True:
# shutil.rmtree(qcDir)
#os.mkdir(qcDir)
qcFcResults = []
bic = []
aic = []
subsMdl = []
models = []
for proc in procBase:
for mdl in statModels:
fcMats = []
meanMov = []
stdMov = []
movFcR = []
center = []
timepoint = []
subIds = []
incSubs = []
excSubs = []
currentModel = proc + mdl
print( currentModel )
for sub in sorted(os.listdir(baseDir)):
subDir = baseDir + '/' + sub + '/' + '/QA_' + currentModel + '_AGG'
fdFile = baseDir + '/' + sub + '/maximum_disp.1d_delt'
fcFile = subDir + '/FC_' + mdl + '_local_global_cobra.txt'
nodeFile = subDir + '/FC_' + mdl + '_local_global_cobra_node.txt'
if os.path.isfile(fcFile): #os.path.isfile(fdFile)
fd = np.loadtxt(fdFile)
fc = np.loadtxt(fcFile)
nodes = np.loadtxt(nodeFile)
fcN = np.zeros((600,600)) * np.nan
idx1 = 0
for n1 in nodes[1:]:
idx2 = 0;
for n2 in nodes[1:]:
fcN[int(n1-1), int(n2-1)] = fc[idx1,idx2]
idx2 += 1
idx1 += 1
print('Processing: ' + sub)
print('\tMeanFD = {:.03f}'.format(np.mean(fd)))
print('\tMaxFD = {:.03f}'.format(np.max(fd)))
pctScrub = 100*np.count_nonzero( fd>0.4) / len(fd)
print('\tpctScrub = {:.03f}%'.format(pctScrub))
#%
if np.mean(fd) > 0.4 or np.max(fd) > 5 or pctScrub > 33:
excId = 0
if sub[0] == 'B':
excId = 100 + int(sub[3:])
if sub[0] == 'N':
excId = 500 + int(sub[3:])
if sub[1] == '1':
excId += 100
if sub[1] == '2':
excId += 200
if sub[1] == '3':
excId += 300
excSubs.append( excId )
continue
excId = 0
if sub[0] == 'B':
excId = 100 + int(sub[3:])
if sub[0] == 'N':
excId = 500 + int(sub[3:])
if sub[1] == '1':
excId += 100
if sub[1] == '2':
excId += 200
if sub[1] == '3':
excId += 300
incSubs.append( excId )
if sub[0] == 'B':
center.append(1)
subIds.append(100 + int(sub[3:]))
if sub[0] == 'N':
center.append(10)
subIds.append(200 + int(sub[3:]))
if sub[1] == '1':
timepoint.append(1)
if sub[1] == '2':
timepoint.append(2)
if sub[1] == '3':
timepoint.append(3)
#tmp = fcN[uNodes,:]
#tmp = tmp[0,:,uNodes]
# No cerebellum included
tmp = fcN[0:400,:]
tmp = tmp[:,0:400]
fcMats.append( | np.squeeze(tmp) | numpy.squeeze |
from blackbox_selectinf.usecase.DTL import DropTheLoser
from blackbox_selectinf.learning.learning import (learn_select_prob, get_weight, get_CI)
import DTL_vae
import numpy as np
import argparse
import pickle
from regreg.smooth.glm import glm
from selectinf.algorithms import lasso
from scipy.stats import norm
import matplotlib.pyplot as plt
import torch
from selectinf.distributions.discrete_family import discrete_family
from argparse import Namespace
parser = argparse.ArgumentParser(description='DTL')
parser.add_argument('--idx', type=int, default=0)
parser.add_argument('--selection', type=str, default='mean')
parser.add_argument('--uc', type=float, default=2)
parser.add_argument('--basis_type', type=str, default='naive')
parser.add_argument('--indep', action='store_true', default=False)
parser.add_argument('--K', type=int, default=50)
parser.add_argument('--n', type=int, default=1000)
parser.add_argument('--m', type=int, default=500)
parser.add_argument('--n_b', type=int, default=1000)
parser.add_argument('--m_b', type=int, default=500)
parser.add_argument('--nrep', type=int, default=1)
parser.add_argument('--savemodel', action='store_true', default=False)
parser.add_argument('--modelname', type=str, default='model_')
parser.add_argument('--epochs', type=int, default=3000)
parser.add_argument('--batch_size', type=int, default=100)
parser.add_argument('--ntrain', type=int, default=5000)
parser.add_argument('--logname', type=str, default='log_')
parser.add_argument('--loadmodel', action='store_true', default=False)
parser.add_argument('--use_vae', action='store_true', default=False)
parser.add_argument('--nonnull', action='store_true', default=False)
args = parser.parse_args()
def main():
seed = args.idx
n = args.n
m = args.m
n_b = args.n_b
m_b = args.m_b
K = args.K
uc = args.uc
selection = args.selection
ntrain = args.ntrain
mu_list = np.zeros(K)
if args.nonnull:
mu_list[:25] = .1
logs = [dict() for x in range(args.nrep)]
for j in range(args.idx, args.idx + args.nrep):
print("Starting simulation", j)
logs[j - args.idx]['seed'] = j
np.random.seed(j)
X = np.zeros([K, n])
for k in range(K):
X[k, :] = np.random.randn(n) + mu_list[k]
X_bar = np.mean(X, 1)
if selection == 'mean':
max_rest = np.sort(X_bar)[-2]
win_idx = np.argmax(X_bar)
elif selection == "UC":
UC = X_bar + uc * np.std(X, axis=1, ddof=1)
win_idx = np.argmax(UC)
max_rest = np.sort(UC)[-2]
else:
raise AssertionError("invalid selection")
# Stage 2
X_2 = np.random.randn(m) + mu_list[win_idx]
DTL_class = DropTheLoser(X, X_2)
basis_type = args.basis_type
Z_data = DTL_class.basis(X, X_2, basis_type)
theta_data = DTL_class.theta_hat
print("Generate initial data")
training_data = DTL_class.gen_train_data(ntrain=ntrain, n_b=n_b, m_b=m_b, basis_type=args.basis_type, remove_D0=args.indep)
Z_train = training_data['Z_train']
W_train = training_data['W_train']
gamma = training_data['gamma']
print(np.mean(W_train))
if args.use_vae and np.mean(W_train) <= .1:
print("Start generating more positive data")
pos_ind = W_train == 1
Z_pos = torch.tensor(Z_train[pos_ind, :], dtype=torch.float)
input_dim = Z_pos.shape[1]
bottleneck_dim = 10
vae_model = DTL_vae.VAE(input_dim, bottleneck_dim)
vae_path = "DTL_VAE_seed_{}_n_{}_K_{}_m_{}.pt".format(seed, n, K, m)
output_dim = n * K + m
decoder = DTL_vae.Decoder(input_dim, output_dim)
decoder_path = "DTL_decoder_seed_{}_n_{}_K_{}_m_{}.pt".format(seed, n, K, m)
try:
vae_model.load_state_dict(torch.load(vae_path))
decoder.load_state_dict(torch.load(decoder_path))
except:
print("no model found, start training")
DTL_vae.train_networks(n, K, bottleneck_dim, Z_pos, vae_path, decoder_path, output_dim, print_every=100, dec_epochs=2)
vae_model.load_state_dict(torch.load(vae_path))
decoder.load_state_dict(torch.load(decoder_path))
n_vae = ntrain
Z_vae = vae_model.decode(torch.randn(n_vae, bottleneck_dim))
X_vae = decoder(Z_vae).detach().numpy()
X_vae_1 = X_vae[:, :n * K].reshape(-1, K, n)
X_vae_2 = X_vae[:, n * K:].reshape(-1, m)
Z_train_vae = np.zeros([n_vae, K + 1])
W_train_vae = np.zeros(n_vae)
print("Start generating data using VAE+decoder")
for i in range(n_vae):
X_1_b = X_vae_1[i, :, :]
X_2_b = X_vae_2[i, :]
X_bar_b = np.mean(X_1_b, 1)
if np.argmax(X_bar_b) == win_idx:
W_train_vae[i] = 1
Z_train_vae[i, :] = DTL_class.basis(X_1_b, X_2_b, basis_type=basis_type)
Z_train = np.concatenate([Z_train, Z_train_vae])
W_train = np.concatenate([W_train, W_train_vae])
print(Z_train.shape)
# train
print("Start learning selection probability")
net, flag, pr_data = learn_select_prob(Z_train, W_train, Z_data=torch.tensor(Z_data, dtype=torch.float),
num_epochs=args.epochs, batch_size=args.batch_size, verbose=True)
print('pr_data', pr_data)
logs[j - args.idx]['pr_data'] = pr_data
logs[j - args.idx]['flag'] = flag
if args.indep:
gamma_D0 = training_data['gamma_D0']
Z_data = Z_data - gamma_D0 @ DTL_class.D_0.reshape(1, )
N_0 = Z_data - gamma @ theta_data.reshape(1, )
target_var = 1 / (n + m)
target_sd = np.sqrt(target_var)
gamma_list = np.linspace(-20 / np.sqrt(n_b + m_b), 20 / np.sqrt(n_b + m_b), 101)
target_theta = theta_data + gamma_list
target_theta = target_theta.reshape(1, 101)
weight_val = get_weight(net, target_theta, N_0, gamma)
interval_nn, pvalue_nn = get_CI(target_theta, weight_val, target_var, theta_data, return_pvalue=True)
logs[j - args.idx]['interval_nn'] = interval_nn
if interval_nn[0] <= mu_list[DTL_class.win_idx] <= interval_nn[1]:
logs[j - args.idx]['covered_nn'] = 1
else:
logs[j - args.idx]['covered_nn'] = 0
logs[j - args.idx]['width_nn'] = interval_nn[1] - interval_nn[0]
logs[j - args.idx]['pvalue_nn'] = pvalue_nn
print("pvalue", pvalue_nn)
##################################################
# check learning
count = 0
nb = 50
X_pooled = np.concatenate([X[win_idx], X_2])
pval = []
for ell in range(int(nb / np.mean(W_train))):
X_b = np.zeros([K, n_b])
for k in range(K):
if k != win_idx:
X_b[k, :] = X[k, | np.random.choice(n, n_b, replace=True) | numpy.random.choice |
import tensorflow as tf
import tensorflow.keras.losses as kls
import tensorflow.keras.optimizers as ko
import numpy as np
from tools import ProgressBar
class A2CAgent:
def __init__(self, lr=7e-3, gamma=0.99, value_c=0.5, entropy_c=1e-4):
# `gamma` is the discount factor
self.gamma = gamma
# Coefficients are used for the loss terms.
self.value_c = value_c
self.entropy_c = entropy_c
self.lr = lr
def _value_loss(self, returns, value):
# Value loss is typically MSE between value estimates and returns.
return self.value_c * kls.mean_squared_error(returns, value)
def _logits_loss(self, actions_and_advantages, logits):
# A trick to input actions and advantages through the same API.
actions, advantages = tf.split(actions_and_advantages, 2, axis=-1)
# Sparse categorical CE loss obj that supports sample_weight arg on `call()`.
# `from_logits` argument ensures transformation into normalized probabilities.
weighted_sparse_ce = kls.SparseCategoricalCrossentropy(from_logits=True)
# Policy loss is defined by policy gradients, weighted by advantages.
# Note: we only calculate the loss on the actions we've actually taken.
actions = tf.cast(actions, tf.int32)
policy_loss = weighted_sparse_ce(actions, logits, sample_weight=advantages)
# Entropy loss can be calculated as cross-entropy over itself.
probs = tf.nn.softmax(logits)
entropy_loss = kls.categorical_crossentropy(probs, probs)
# We want to minimize policy and maximize entropy losses.
# Here signs are flipped because the optimizer minimizes.
return policy_loss - self.entropy_c * entropy_loss
def train(self, env, config, batch_size=128, updates=500, max_seconds = 30):
models = config.get()
for model in models:
model.compile(optimizer=ko.RMSprop(lr=self.lr),
loss=[self._logits_loss, self._value_loss])
# Storage helpers for a single batch of data.
actions = | np.empty((batch_size, config.num), dtype=np.int32) | numpy.empty |
## test_attack.py -- sample code to test attack procedure
##
## Copyright (C) 2017, <NAME> <<EMAIL>>.
## Copyright (C) 2016, <NAME> <<EMAIL>>.
##
## This program is licenced under the BSD 2-Clause licence,
## contained in the LICENCE file in this directory.
import tensorflow as tf
import numpy as np
import time
import random
import _pickle as pickle
import os
import scipy
from setup_cifar import CIFAR, CIFARModel
from setup_mnist import MNIST, MNISTModel
from setup_inception import ImageNet, InceptionModel
from l2_attack import CarliniL2
from l1_attack import EADL1
from en_attack import EADEN
from fgm import FGM
from ifgm import IFGM
from PIL import Image
def show(img, name = "output.png"):
fig = (img + 0.5)*255
fig = fig.astype(np.uint8).squeeze()
pic = Image.fromarray(fig)
# pic.resize((512,512), resample=PIL.Image.BICUBIC)
pic.save(name)
def generate_data(data, model, samples, targeted=True, target_num=9, start=0, inception=False, handpick=True, train=False, leastlikely=False,
sigma=0., seed=3):
random.seed(seed)
inputs = []
targets = []
labels = []
true_ids = []
sample_set = []
"""
Generate the input data to the attack algorithm.
"""
if train:
data_d = data.train_data
labels_d = data.train_labels
else:
data_d = data.test_data
labels_d = data.test_labels
if handpick:
if inception:
deck = list(range(0,int(1.5 * samples)))
else:
deck = list(range(0,10000))
random.shuffle(deck)
print('Handpicking')
while(len(sample_set) < samples):
rand_int = deck.pop()
pred = model.model.predict(data_d[rand_int:rand_int+1])
if inception:
pred = np.reshape(pred, (labels_d[0:1].shape))
if(np.argmax(pred,1) == np.argmax(labels_d[rand_int:rand_int+1],1)):
sample_set.append(rand_int)
print('Handpicked')
else:
if inception:
sample_set = random.sample(range(0,int(1.5 * samples)),samples)
else:
sample_set = random.sample(range(0,10000),samples)
for i in sample_set:
if targeted:
if inception:
r = list(range(1,1001))
else:
r = list(range(labels_d.shape[1]))
r.remove(np.argmax(labels_d[start+i]))
seq = random.sample(r, target_num)
for j in seq:
inputs.append(data_d[start+i])
targets.append(np.eye(labels_d.shape[1])[j])
labels.append(labels_d[start+i])
true_ids.append(start+i)
else:
inputs.append(data_d[start+i])
targets.append(labels_d[start+i])
labels.append(labels_d[start+i])
true_ids.append(start+i)
inputs = np.array(inputs)
targets = np.array(targets)
labels = np.array(labels)
true_ids = np.array(true_ids)
return inputs, targets, labels, true_ids
def main(args):
with tf.Session() as sess:
if (args['dataset'] == 'mnist'):
data = MNIST()
inception=False
if (args['adversarial'] != "none"):
model = MNISTModel("models/mnist_cw"+str(args['adversarial']), sess)
elif (args['temp']):
model = MNISTModel("models/mnist-distilled-"+str(args['temp']), sess)
else:
model = MNISTModel("models/mnist", sess)
if (args['dataset'] == "cifar"):
data = CIFAR()
inception=False
if (args['adversarial'] != "none"):
model = CIFARModel("models/cifar_cw"+str(args['adversarial']), sess)
elif (args['temp']):
model = CIFARModel("models/cifar-distilled-"+str(args['temp']), sess)
else:
model = CIFARModel("models/cifar", sess)
if (args['dataset'] == "imagenet"):
data, model = ImageNet(args['seed_imagenet'], 2*args['numimg']), InceptionModel(sess)
inception=True
inputs, targets, labels, true_ids = generate_data(data, model, samples=args['numimg'], targeted = not args['untargeted'], target_num = args['targetnum'],
inception=inception, train=args['train'],
seed=args['seed'])
timestart = time.time()
if(args['restore_np']):
if(args['train']):
adv = np.load(str(args['dataset'])+'_'+str(args['attack'])+'_train.npy')
else:
adv = np.load(str(args['dataset'])+'_'+str(args['attack'])+'.npy')
else:
if (args['attack'] == 'L2'):
attack = CarliniL2(sess, model, batch_size=args['batch_size'], max_iterations=args['maxiter'], confidence=args['conf'], initial_const=args['init_const'],
binary_search_steps=args['binary_steps'], targeted = not args['untargeted'], beta=args['beta'], abort_early=args['abort_early'])
adv = attack.attack(inputs, targets)
if (args['attack'] == 'L1'):
attack = EADL1(sess, model, batch_size=args['batch_size'], max_iterations=args['maxiter'], confidence=args['conf'], initial_const=args['init_const'],
binary_search_steps=args['binary_steps'], targeted = not args['untargeted'], beta=args['beta'], abort_early=args['abort_early'])
adv = attack.attack(inputs, targets)
if (args['attack'] == 'EN'):
attack = EADEN(sess, model, batch_size=args['batch_size'], max_iterations=args['maxiter'], confidence=args['conf'], initial_const=args['init_const'],
binary_search_steps=args['binary_steps'], targeted = not args['untargeted'], beta=args['beta'], abort_early=args['abort_early'])
adv = attack.attack(inputs, targets)
"""If untargeted, pass labels instead of targets"""
if (args['attack'] == 'FGSM'):
attack = FGM(sess, model, batch_size=args['batch_size'], ord=np.inf, eps=args['eps'], inception=inception)
adv = attack.attack(inputs, targets)
if (args['attack'] == 'FGML1'):
attack = FGM(sess, model, batch_size=args['batch_size'], ord=1, eps=args['eps'], inception=inception)
adv = attack.attack(inputs, targets)
if (args['attack'] == 'FGML2'):
attack = FGM(sess, model, batch_size=args['batch_size'], ord=2, eps=args['eps'], inception=inception)
adv = attack.attack(inputs, targets)
if (args['attack'] == 'IFGSM'):
attack = IFGM(sess, model, batch_size=args['batch_size'], ord=np.inf, eps=args['eps'], inception=inception)
adv = attack.attack(inputs, targets)
if (args['attack'] == 'IFGML1'):
attack = IFGM(sess, model, batch_size=args['batch_size'], ord=1, eps=args['eps'], inception=inception)
adv = attack.attack(inputs, targets)
if (args['attack'] == 'IFGML2'):
attack = IFGM(sess, model, batch_size=args['batch_size'], ord=2, eps=args['eps'], inception=inception)
adv = attack.attack(inputs, targets)
timeend = time.time()
if args['untargeted']:
num_targets = 1
else:
num_targets = args['targetnum']
print("Took",timeend-timestart,"seconds to run",len(inputs)/num_targets,"random instances.")
if(args['save_np']):
if(args['train']):
np.save(str(args['dataset'])+'_labels_train.npy',labels)
np.save(str(args['dataset'])+'_'+str(args['attack'])+'_train.npy',adv)
else:
np.save(str(args['dataset'])+'_'+str(args['attack']+'.npy'),adv)
r_best_ = []
d_best_l1_ = []
d_best_l2_ = []
d_best_linf_ = []
r_average_ = []
d_average_l1_ = []
d_average_l2_ = []
d_average_linf_ = []
r_worst_ = []
d_worst_l1_ = []
d_worst_l2_ = []
d_worst_linf_ = []
#Transferability Tests
model_ = []
model_.append(model)
if (args['targetmodel'] != "same"):
if(args['targetmodel'] == "dd_100"):
model_.append(MNISTModel("models/mnist-distilled-100", sess))
num_models = len(model_)
if (args['show']):
if not os.path.exists(str(args['save'])+"/"+str(args['dataset'])+"/"+str(args['attack'])):
os.makedirs(str(args['save'])+"/"+str(args['dataset'])+"/"+str(args['attack']))
for m,model in enumerate(model_):
r_best = []
d_best_l1 = []
d_best_l2 = []
d_best_linf = []
r_average = []
d_average_l1 = []
d_average_l2 = []
d_average_linf = []
r_worst = []
d_worst_l1 = []
d_worst_l2 = []
d_worst_linf = []
for i in range(0,len(inputs),num_targets):
pred = []
for j in range(i,i+num_targets):
if inception:
pred.append(np.reshape(model.model.predict(adv[j:j+1]), (data.test_labels[0:1].shape)))
else:
pred.append(model.model.predict(adv[j:j+1]))
dist_l1 = 1e10
dist_l1_index = 1e10
dist_linf = 1e10
dist_linf_index = 1e10
dist_l2 = 1e10
dist_l2_index = 1e10
for k,j in enumerate(range(i,i+num_targets)):
success = False
if(args['untargeted']):
if(np.argmax(pred[k],1) != np.argmax(targets[j:j+1],1)):
success = True
else:
if(np.argmax(pred[k],1) == np.argmax(targets[j:j+1],1)):
success = True
if(success):
if(np.sum(np.abs(adv[j]-inputs[j])) < dist_l1):
dist_l1 = np.sum(np.abs(adv[j]-inputs[j]))
dist_l1_index = j
if(np.amax(np.abs(adv[j]-inputs[j])) < dist_linf):
dist_linf = np.amax(np.abs(adv[j]-inputs[j]))
dist_linf_index = j
if((np.sum((adv[j]-inputs[j])**2)**.5) < dist_l2):
dist_l2 = (np.sum((adv[j]-inputs[j])**2)**.5)
dist_l2_index = j
if(dist_l1_index != 1e10):
d_best_l2.append((np.sum((adv[dist_l2_index]-inputs[dist_l2_index])**2)**.5))
d_best_l1.append(np.sum(np.abs(adv[dist_l1_index]-inputs[dist_l1_index])))
d_best_linf.append(np.amax(np.abs(adv[dist_linf_index]-inputs[dist_linf_index])))
r_best.append(1)
else:
r_best.append(0)
rand_int = np.random.randint(i,i+num_targets)
if inception:
pred_r = np.reshape(model.model.predict(adv[rand_int:rand_int+1]), (data.test_labels[0:1].shape))
else:
pred_r = model.model.predict(adv[rand_int:rand_int+1])
success_average = False
if(args['untargeted']):
if(np.argmax(pred_r,1) != np.argmax(targets[rand_int:rand_int+1],1)):
success_average = True
else:
if(np.argmax(pred_r,1) == np.argmax(targets[rand_int:rand_int+1],1)):
success_average = True
if success_average:
r_average.append(1)
d_average_l2.append(np.sum((adv[rand_int]-inputs[rand_int])**2)**.5)
d_average_l1.append(np.sum(np.abs(adv[rand_int]-inputs[rand_int])))
d_average_linf.append(np.amax(np.abs(adv[rand_int]-inputs[rand_int])))
else:
r_average.append(0)
dist_l1 = 0
dist_l1_index = 1e10
dist_linf = 0
dist_linf_index = 1e10
dist_l2 = 0
dist_l2_index = 1e10
for k,j in enumerate(range(i,i+num_targets)):
failure = True
if(args['untargeted']):
if(np.argmax(pred[k],1) != np.argmax(targets[j:j+1],1)):
failure = False
else:
if(np.argmax(pred[k],1) == np.argmax(targets[j:j+1],1)):
failure = False
if failure:
r_worst.append(0)
dist_l1_index = 1e10
dist_l2_index = 1e10
dist_linf_index = 1e10
break
else:
if(np.sum(np.abs(adv[j]-inputs[j])) > dist_l1):
dist_l1 = np.sum(np.abs(adv[j]-inputs[j]))
dist_l1_index = j
if(np.amax(np.abs(adv[j]-inputs[j])) > dist_linf):
dist_linf = np.amax(np.abs(adv[j]-inputs[j]))
dist_linf_index = j
if((np.sum((adv[j]-inputs[j])**2)**.5) > dist_l2):
dist_l2 = (np.sum((adv[j]-inputs[j])**2)**.5)
dist_l2_index = j
if(dist_l1_index != 1e10):
d_worst_l2.append((np.sum((adv[dist_l2_index]-inputs[dist_l2_index])**2)**.5))
d_worst_l1.append(np.sum(np.abs(adv[dist_l1_index]-inputs[dist_l1_index])))
d_worst_linf.append(np.amax(np.abs(adv[dist_linf_index]-inputs[dist_linf_index])))
r_worst.append(1)
if(args['show'] and m == (num_models-1)):
for j in range(i,i+num_targets):
target_id = np.argmax(targets[j:j+1],1)
label_id = np.argmax(labels[j:j+1],1)
prev_id = np.argmax(np.reshape(model.model.predict(inputs[j:j+1]),(data.test_labels[0:1].shape)),1)
adv_id = np.argmax(np.reshape(model.model.predict(adv[j:j+1]),(data.test_labels[0:1].shape)),1)
suffix = "id{}_seq{}_lbl{}_prev{}_adv{}_{}_l1_{:.3f}_l2_{:.3f}_linf_{:.3f}".format(true_ids[i],
target_id,
label_id,
prev_id,
adv_id, adv_id == target_id,
np.sum(np.abs(adv[j]-inputs[j])), np.sum((adv[j]-inputs[j])**2)**.5, np.amax(np.abs(adv[j]-inputs[j])))
show(inputs[j:j+1], str(args['save'])+"/"+str(args['dataset'])+"/"+str(args['attack'])+"/original_{}.png".format(suffix))
show(adv[j:j+1], str(args['save'])+"/"+str(args['dataset'])+"/"+str(args['attack'])+"/adversarial_{}.png".format(suffix))
if(m != (num_models - 1)):
lbl = "Src_"
if(num_models > 2):
lbl += str(m) + "_"
else:
lbl = "Tgt_"
if(num_targets > 1):
print(lbl+'best_case_L1_mean', np.mean(d_best_l1))
print(lbl+'best_case_L2_mean', np.mean(d_best_l2))
print(lbl+'best_case_Linf_mean', np.mean(d_best_linf))
print(lbl+'best_case_prob', np.mean(r_best))
print(lbl+'average_case_L1_mean', np.mean(d_average_l1))
print(lbl+'average_case_L2_mean', np.mean(d_average_l2))
print(lbl+'average_case_Linf_mean', np.mean(d_average_linf))
print(lbl+'average_case_prob', np.mean(r_average))
print(lbl+'worst_case_L1_mean', np.mean(d_worst_l1))
print(lbl+'worst_case_L2_mean', np.mean(d_worst_l2))
print(lbl+'worst_case_Linf_mean', | np.mean(d_worst_linf) | numpy.mean |
import os
import pickle
import torch
import numpy as np
from torch import nn
from scipy.stats import linregress
from sklearn.datasets import make_blobs
from collections.abc import Iterable
import matplotlib.pyplot as plt
from utils.config import *
def get_blobs(feature_dim, num_samples=1000,
split=0.95, cluster_std=[1., 1.],
transform=None, plot=False):
'''
Creates some toy datasets that can be used for testing Fractal Dimension approaches. Got some ideas from:
https://scikit-learn.org/stable/auto_examples/cluster/plot_kmeans_assumptions.html#sphx-glr-auto-examples-cluster-plot-kmeans-assumptions-py
'''
# check for low positive training examples
assert split > 0.5, f"WARNING: split was set to less than 0.5, did you mean to use {1-split}?"
# check if plot is set to true but wrong feature_dim
if plot and feature_dim > 2:
print(f"Feature_dim set to larger than 2 with plot set to false, setting plot to False")
plot = False
# init proper class sizes and blob centers
centers = [[-1]*feature_dim, [1]*feature_dim]
class_sizes = [int(num_samples*split), int((1-split)*num_samples)]
X, y = make_blobs(n_samples=class_sizes, cluster_std=cluster_std, centers=centers)
# carry out anisotropic transformation; only works for feature_dim of 2
if transform and feature_dim == 2:
transformation = [[-0.5, 0.5], [-0.5, 1]]
X = np.dot(X, transformation)
# view plot
if plot:
plt.figure(figsize=(5, 4))
plt.scatter(X[:, 0], X[:, 1], alpha=0.6,
c=['r' if i == 1 else 'g' for i in y])
plt.xlabel(r'$X_1$')
plt.ylabel(r'$X_2$')
#plt.savefig("images/blobs.png", dpi=150, bbox_inches='tight')
return X, y
def import_corpus(event):
'''
Import the corpus from the sandy pickled events.
args:
events : thread, registry or file
returns:
corpus : list of strings, corresponding to API usage by process
targets : int value for malicious label, where 1 is malicious 0 is benign
attr : dict of attributes, see generate_corpus.py
'''
file = os.path.join(SANDY_ATTR_PATH, f'corpus.{event}.pkl')
# fetch corpus and attributes
corpus = pickle.load(open(file, "rb" ))
attr = pickle.load(open(os.path.join(SANDY_ATTR_PATH, f'attr.{event}.pkl'), "rb" ))
# fetch targets from attribute dict
targets = attr['target_arr']
del attr['target_arr']
return corpus, targets, attr
def mass_fd(X, k=5, skip=0, norm=2, gyration=True, ratios=False, verbose=False):
'''
Determine the mass radius or radius of gyration fractal dimension. Numpy implemention used for quick
prototyping.
args:
X - (n, m) feature vector. Can be any m-th dimensional data, with n datapoints
k - number of scales to use
skip - skip some points on the log-log plot. Helps on occasionn for numerical stability in the upper/lower range
norm - the norm for the generalized distance metric, where 1 = Manhattan, 2 = Euclidean, 3+ = Minkowski
gyration - flag to enable radius of gyration instead of mass-radius
ratios - flag to enable the use of ratios of std. devs between scales. Doesn't work well :(
verbose - plot the log-log plot and print some metadata
returns:
D - returns the fractal dimension of the input
'''
# sanity check so enough points are considered for log-log plot
assert k - skip >= 2, f"Not enough points on the log-log plot to consider, you used: {k=} and {skip=} and need at least 2"
# make X an iterable so that we can run the loop regardless *need to fix this check*
if not isinstance(X, Iterable) or isinstance(X, np.ndarray):
X = [X]
else:
verbose = False # remove verbose for Iterable
# main loop
D = []
for x in X:
D.append(mass_fd_aux(x=x, k=k, skip=skip, norm=norm, gyration=gyration, ratios=ratios, verbose=verbose))
# * this is returning an extra dimension for np.array*
return D
def mass_fd_aux(x, k=5, skip=0, norm=2, gyration=True, ratios=False, verbose=False):
# remove zero values
x = x[~np.all(x == 0, axis=1)]
# mean along each axis
centroid = x.mean(axis=0)
# find distances and sort by proximity to centroid
dist = np.power(np.sum(np.abs(x - centroid) ** norm, axis=1), 1. / norm)
dist_idx_sorted = np.argsort(dist)
# split distances array into k partitions
N = np.array_split(dist_idx_sorted, k)
# points for log-log plot
Rg = []
Nk = []
# loop through scales
for i in range(k):
# concatenates sucessive nodes away from centroid (e.g Nk_1, Nk_1 + Nk_2)
Nj = x[np.concatenate(N[:i+1])]
# compute the centroid for each k if using ROG
if gyration:
centroid = Nj.mean(axis=0)
# compute the std. dev in all d dimensions
Rg.append(np.power(np.sum(np.abs(Nj - centroid) ** norm) / len(Nj), 1. / norm))
# append the number of nodes considered
Nk.append(Nj.shape[0])
# vanilla implementation, just used the raw std. devs.
if not ratios:
log_Rg = np.log(Rg)[:-skip] if skip != 0 else np.log(Rg)
log_Nk = | np.log(Nk) | numpy.log |
import numpy as np
import pickle
import sys
import time
import torch
import yaml
from baller2vecplusplus import Baller2VecPlusPlus
from baller2vecplusplus_dataset import Baller2VecPlusPlusDataset
from settings import *
from torch import nn, optim
from torch.utils.data import DataLoader
from toy_dataset import ToyDataset
SEED = 2010
torch.manual_seed(SEED)
torch.set_printoptions(linewidth=160)
np.random.seed(SEED)
def worker_init_fn(worker_id):
# See: https://pytorch.org/docs/stable/notes/faq.html#my-data-loader-workers-return-identical-random-numbers
# and: https://pytorch.org/docs/stable/data.html#multi-process-data-loading
# and: https://pytorch.org/docs/stable/data.html#randomness-in-multi-process-data-loading.
# NumPy seed takes a 32-bit unsigned integer.
np.random.seed(int(torch.utils.data.get_worker_info().seed) % (2 ** 32 - 1))
def get_train_valid_test_gameids():
with open("train_gameids.txt") as f:
train_gameids = f.read().split()
with open("valid_gameids.txt") as f:
valid_gameids = f.read().split()
with open("test_gameids.txt") as f:
test_gameids = f.read().split()
return (train_gameids, valid_gameids, test_gameids)
def init_basketball_datasets(opts):
baller2vec_config = pickle.load(open(f"{DATA_DIR}/baller2vec_config.pydict", "rb"))
n_player_ids = len(baller2vec_config["player_idx2props"])
(train_gameids, valid_gameids, test_gameids) = get_train_valid_test_gameids()
dataset_config = opts["dataset"]
dataset_config["gameids"] = train_gameids
dataset_config["N"] = opts["train"]["train_samples_per_epoch"]
dataset_config["starts"] = []
dataset_config["mode"] = "train"
dataset_config["n_player_ids"] = n_player_ids
train_dataset = Baller2VecPlusPlusDataset(**dataset_config)
train_loader = DataLoader(
dataset=train_dataset,
batch_size=None,
num_workers=opts["train"]["workers"],
worker_init_fn=worker_init_fn,
)
N = opts["train"]["valid_samples"]
samps_per_gameid = int(np.ceil(N / len(valid_gameids)))
starts = []
for gameid in valid_gameids:
y = np.load(f"{GAMES_DIR}/{gameid}_y.npy")
max_start = len(y) - train_dataset.chunk_size
gaps = max_start // samps_per_gameid
starts.append(gaps * np.arange(samps_per_gameid))
dataset_config["gameids"] = np.repeat(valid_gameids, samps_per_gameid)
dataset_config["N"] = len(dataset_config["gameids"])
dataset_config["starts"] = np.concatenate(starts)
dataset_config["mode"] = "valid"
valid_dataset = Baller2VecPlusPlusDataset(**dataset_config)
valid_loader = DataLoader(
dataset=valid_dataset,
batch_size=None,
num_workers=opts["train"]["workers"],
)
samps_per_gameid = int(np.ceil(N / len(test_gameids)))
starts = []
for gameid in test_gameids:
y = np.load(f"{GAMES_DIR}/{gameid}_y.npy")
max_start = len(y) - train_dataset.chunk_size
gaps = max_start // samps_per_gameid
starts.append(gaps * np.arange(samps_per_gameid))
dataset_config["gameids"] = np.repeat(test_gameids, samps_per_gameid)
dataset_config["N"] = len(dataset_config["gameids"])
dataset_config["starts"] = | np.concatenate(starts) | numpy.concatenate |
# Author: <NAME>, 02/09/2022
from matplotlib import pyplot as plt
from PIL import Image
import numpy as np
# DLT
def compute_A(X, X_):
A_list = []
zero = | np.zeros(3) | numpy.zeros |
import numpy as np
from MagniPy.lensdata import Data
import subprocess
import shutil
import scipy.ndimage.filters as sfilt
import itertools
from copy import deepcopy
def dr(x1,x2,y1,y2):
return np.sqrt((x1-x2)**2+(y1-y2)**2)
def snap_to_bins(data, xbin_centers, dx, ybin_centers, dy, ranges):
new_datax = deepcopy(data[:, 0])
new_datay = deepcopy(data[:, 1])
new_datax[np.where(new_datax <= ranges[0][0])] = xbin_centers[0]
new_datax[np.where(new_datax >= ranges[0][1])] = xbin_centers[-1]
new_datay[np.where(new_datay <= ranges[1][0])] = ybin_centers[0]
new_datay[np.where(new_datay >= ranges[1][1])] = ybin_centers[-1]
new_data = None
xx, yy = np.meshgrid(xbin_centers, ybin_centers)
coords = zip(np.round(xx.ravel(), 4), np.round(yy.ravel(), 4))
for i, (cenx, ceny) in enumerate(coords):
subx = np.absolute(new_datax - cenx) * dx ** -1
suby = np.absolute(new_datay - ceny) * dy ** -1
inds = np.where(np.logical_and(subx < 1, suby < 1))[0]
if len(inds) > 0:
new_array = np.column_stack((np.array([cenx] * len(inds)), np.array([ceny] * len(inds))))
if new_data is None:
new_data = deepcopy(new_array)
else:
new_data = np.vstack((new_data, new_array))
return new_data
def approx_theta_E(ximg,yimg):
dis = []
xinds,yinds = [0,0,0,1,1,2],[1,2,3,2,3,3]
for (i,j) in zip(xinds,yinds):
dx,dy = ximg[i] - ximg[j], yimg[i] - yimg[j]
dr = (dx**2+dy**2)**0.5
dis.append(dr)
dis = np.array(dis)
greatest = np.argmax(dis)
dr_greatest = dis[greatest]
dis[greatest] = 0
second_greatest = np.argmax(dis)
dr_second = dis[second_greatest]
return 0.5*(dr_greatest*dr_second)**0.5
def min_img_sep_ranked(ximg, yimg):
ximg, yimg = np.array(ximg), np.array(yimg)
d1 = dr(ximg[0], ximg[1:], yimg[0], yimg[1:])
d2 = dr(ximg[1], [ximg[0], ximg[2], ximg[3]], yimg[1],
[yimg[0], yimg[2], yimg[3]])
d3 = dr(ximg[2], [ximg[0], ximg[1], ximg[3]], yimg[2],
[yimg[0], yimg[1], yimg[3]])
d4 = dr(ximg[3], [ximg[0], ximg[1], ximg[2]], yimg[3],
[yimg[0], yimg[1], yimg[2]])
idx1 = np.argmin(d1)
idx2 = np.argmin(d2)
idx3 = np.argmin(d3)
idx4 = np.argmin(d4)
x_2, x_3, x_4 = [ximg[0], ximg[2], ximg[3]], [ximg[0], ximg[1], ximg[3]], [ximg[0], ximg[1], ximg[2]]
y_2, y_3, y_4 = [yimg[0], yimg[2], yimg[3]], [yimg[0], yimg[1], yimg[3]], [yimg[0], yimg[1], yimg[2]]
theta1 = np.arctan((yimg[1:][idx1] - yimg[0])/(ximg[1:][idx1] - ximg[0]))
theta2 = np.arctan((y_2[idx2] - yimg[1]) / (x_2[idx2] - ximg[1]))
theta3 = np.arctan((y_3[idx3] - yimg[2]) / (x_3[idx3] - ximg[2]))
theta4 = np.arctan((y_4[idx4] - yimg[3]) / (x_4[idx4] - ximg[3]))
return np.array([np.min(d1), np.min(d2), np.min(d3), np.min(d4)]), np.array([theta1, theta2,
theta3, theta4])
def min_img_sep(ximg,yimg):
assert len(ximg) == len(yimg)
dr = []
if len(ximg) == 1:
return 1
elif len(ximg) == 0:
return 1
try:
for i in range(0,int(len(ximg)-1)):
for j in range(i+1,int(len(ximg))):
dx = ximg[i] - ximg[j]
dy = yimg[i] - yimg[j]
dr.append((dx**2 + dy**2)**0.5)
return min(dr)
except:
print('problem with the fit...')
return 1
def sort_image_index(ximg,yimg,xref,yref):
assert len(xref) == len(ximg)
x_self = np.array(list(itertools.permutations(ximg)))
y_self = np.array(list(itertools.permutations(yimg)))
indexes = [0, 1, 2, 3]
index_iterations = list(itertools.permutations(indexes))
delta_r = []
for i in range(0, int(len(x_self))):
dr = 0
for j in range(0, int(len(x_self[0]))):
dr += (x_self[i][j] - xref[j]) ** 2 + (y_self[i][j] - yref[j]) ** 2
delta_r.append(dr ** .5)
min_indexes = np.array(index_iterations[np.argmin(delta_r)])
return min_indexes
def coordinates_inbox(box_dx,box_dy,centered_x,centered_y):
return np.logical_and(np.logical_and(-0.5*box_dx < centered_x, centered_x < 0.5*box_dx),
np.logical_and(-0.5*box_dy < centered_y, centered_y < 0.5*box_dy))
def confidence_interval(percentile,data):
data=np.array(data)
data.sort()
L = len(data)
counter = 0
while True:
value = data[counter]
if counter>=L*percentile:
break
counter+=1
return value
def quick_confidence(centers, heights, percentile):
total = np.sum(heights)
summ, index = 0, 0
while summ < total * percentile:
summ += heights[index]
index += 1
return centers[index-1]
def read_data(filename='',N=None):
with open(filename,'r') as f:
lines = f.readlines()
dsets = []
for line in lines:
line = line.split(' ')
n = int(line[0])
try:
srcx,srcy = float(line[1]),float(line[2])
except:
srcx,srcy = None,None
x1,x2,x3,x4,y1,y2,y3,y4 = float(line[3]),float(line[7]),float(line[11]),float(line[15]),float(line[4]),\
float(line[8]),float(line[12]),float(line[16])
m1,m2,m3,m4 = float(line[5]),float(line[9]),float(line[13]),float(line[17])
t1,t2,t3,t4 = float(line[6]),float(line[10]),float(line[14]),float(line[18])
dsets.append(Data(x=[x1,x2,x3,x4],y=[y1,y2,y3,y4],m=[m1,m2,m3,m4],
t=[t1,t2,t3,t4],source=[srcx,srcy]))
if N is not None and len(dsets)>=N:
break
return dsets
def write_fluxes(filename='',fluxes = [], mode='append',summed_in_quad=True):
if summed_in_quad:
fluxes = np.squeeze(fluxes)
with open(filename,'a') as f:
if isinstance(fluxes,float):
f.write(str(fluxes)+'\n')
else:
for val in fluxes:
f.write(str(val)+'\n')
return
fluxes = np.array(fluxes)
if mode == 'append':
m = 'a'
else:
m = 'w'
if fluxes.ndim == 1:
with open(filename, m) as f:
for val in fluxes:
f.write(str(val) + ' ')
f.write('\n')
else:
N = int(np.shape(fluxes)[0])
with open(filename,m) as f:
for n in range(0,N):
for val in fluxes[n,:]:
f.write(str(val)+' ')
f.write('\n')
def write_data(filename='',data_list=[],mode='append'):
def single_line(dset=classmethod):
lines = ''
lines += str(dset.nimg)+' '+str(dset.srcx)+' '+str(dset.srcy)+' '
for i in range(0,int(dset.nimg)):
for value in [dset.x[i],dset.y[i],dset.m[i],dset.t[i]]:
if value is None:
lines += '0 '
else:
lines += str(value)+' '
return lines+'\n'
if mode=='append':
with open(filename,'a') as f:
for dataset in data_list:
f.write(single_line(dataset))
else:
with open(filename,'w') as f:
for dataset in data_list:
f.write(single_line(dataset))
def integrate_profile(profname,limit,inspheres=False,**kwargs):
if profname=='nfw':
rs=kwargs['rs']
ks=kwargs['ks']
n=limit*rs**-1
if inspheres:
rho0 = 86802621404*ks*rs**-1
n*=rs
r200 = kwargs['c']*rs
return 4*np.pi*rho0*rs**3*(np.log(1+r200*n**-1)- n*(n+r200)**-1)
else:
return 2*np.pi*rs**2*ks*(np.log(.25*n**2)+2*np.arctanh(np.sqrt(1-n**2))*(np.sqrt(1-n**2))**-1)
elif profname=='SIE':
b = kwargs['SIE_Rein']
return np.pi*limit*b
def rotate(xcoords,ycoords,angle):
return xcoords*np.cos(angle)+ycoords*np.sin(angle),-xcoords*np.sin(angle)+ycoords*np.cos(angle)
def img_sept(x,y):
return np.sort(np.array([dr(x[0],x[1],y[0],y[1]),dr(x[0],x[2],y[0],y[2]),dr(x[0],x[3],y[0],y[3]),
dr(x[1],x[2],y[1],y[2]),dr(x[1],x[3],y[1],y[3]),dr(x[2],x[3],y[2],y[3])]))
def identify(x,y,RE):
separations = img_sept(x,y)
if separations[0] > RE:
return 0
if separations[1] <= 1.15*RE:
return 2
elif separations[0] <= 0.85*RE:
return 1
else:
return 0
def read_dat_file(fname):
x_srcSIE, y_srcSIE = [], []
with open(fname, 'r') as f:
nextline = False
dosrc = False
doimg = False
count = 0
readcount = 0
for line in f:
row = line.split(" ")
#print(row,fname)
#row_split = filter(None, row)
row_split = list(filter(None, row))
if row_split[0] == 'alpha':
macromodel = row_split
continue
if row_split[0] == 'Source':
nextline = True
dosrc = True
src = []
continue
if nextline and dosrc:
for item in row:
try:
src.append(float(item))
except ValueError:
continue
x_srcSIE.append(src[0])
y_srcSIE.append(src[1])
nextline = False
dosrc = False
continue
if row_split[0] == 'images:\n':
nextline = True
doimg = True
count = 0
x, y, f, t = [], [], [], []
continue
if nextline and doimg:
count += 1
numbers = []
for item in row:
try:
numbers.append(float(item))
except ValueError:
continue
x.append(numbers[4])
y.append(numbers[5])
f.append(numbers[6])
t.append(numbers[7])
if int(count) == 4:
t = np.array(t)
if min(t) < 0:
t += -1 * min(t)
xpos = x
ypos = y
fr = np.array(f)
tdel = np.array(t)
return xpos, ypos, fr, t, macromodel, [x_srcSIE[0], y_srcSIE[0]]
def read_gravlens_out(fnames):
vector = []
if isinstance(fnames,list):
for fname in fnames:
with open(fname, 'r') as f:
lines = f.readlines()
f.close()
imgline = lines[1].split(' ')
numimg = int(imgline[1])
xpos, ypos, mag, tdelay = [], [], [], []
for i in range(0, numimg):
data = lines[2 + i].split(' ')
data = filter(None, data)
xpos.append(float(data[0]))
ypos.append(float(data[1]))
mag.append(np.absolute(float(data[2])))
tdelay.append(float(data[3]))
vector.append([ | np.array(xpos) | numpy.array |
import tensorflow as tf
import numpy as np
from scipy.misc import imsave
def get_pos(x: int, y: int, w: int, h: int):
x = (float(x) - w // 2) / w
y = (float(y) - h // 2) / h
return [x, y, np.sqrt(np.square(x) + | np.square(y) | numpy.square |
# ============================================================================
# Copyright (c) 2018 Diamond Light Source Ltd. 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.
# ============================================================================
# Author: <NAME>
# E-mail: <EMAIL>
# Description: Python implementation of the author's methods of
# distortion correction, <NAME> et al "Radial lens distortion
# correction with sub-pixel accuracy for X-ray micro-tomography"
# Optics Express 23, 32859-32868 (2015), https://doi.org/10.1364/OE.23.032859
# Publication date: 10th July 2018
# ============================================================================
# Contributors:
# ============================================================================
"""
Module of processing methods:
- Fit lines of dots to parabolas, find the center of distortion.
- Calculate undistorted intercepts of gridlines.
- Calculate distortion coefficients of the backward model, the forward model,
and the backward-from-forward model.
- Correct perspective distortion affecting curve lines.
- Generate non-perspective points or lines from perspective points or lines.
- Calculate perspective coefficients.
"""
import numpy as np
from scipy import optimize
def _para_fit_hor(list_lines, xcenter, ycenter):
"""
Fit horizontal lines of dots to parabolas.
Parameters
----------
list_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each line.
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
Returns
-------
list_coef : list of 1D arrays
List of the coefficients of each parabola (y=ax**2+bx+c).
list_slines : list of 2D arrays
List of the shifted (y,x)-coordinates of dot-centroids on each line.
"""
num_line = len(list_lines)
list_coef = np.zeros((num_line, 3), dtype=np.float32)
list_slines = []
for i, iline in enumerate(list_lines):
line = np.asarray(iline)
list_coef[i] = np.asarray(np.polyfit(line[:, 1] - xcenter,
line[:, 0] - ycenter, 2))
list_temp = np.asarray(
[(dot[0] - ycenter, dot[1] - xcenter) for dot in line])
list_slines.append(list_temp)
return list_coef, list_slines
def _para_fit_ver(list_lines, xcenter, ycenter):
"""
Fit vertical lines of dots to parabolas.
Parameters
----------
list_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each line.
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
Returns
-------
list_coef : list of 1D arrays
List of the coefficients of each parabola (x=ay**2+by+c).
list_slines : list of 2D arrays
List of the shifted (y,x)-coordinates of dot-centroids on each line.
"""
num_line = len(list_lines)
list_coef = np.zeros((num_line, 3), dtype=np.float32)
list_slines = []
for i, iline in enumerate(list_lines):
line = np.asarray(iline)
list_coef[i] = np.asarray(
np.polyfit(line[:, 0] - ycenter, line[:, 1] - xcenter, 2))
list_temp = np.asarray(
[(dot[0] - ycenter, dot[1] - xcenter) for dot in line])
list_slines.append(list_temp)
return list_coef, list_slines
def find_cod_coarse(list_hor_lines, list_ver_lines):
"""
Coarse estimation of the center of distortion.
Parameters
----------
list_hor_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each horizontal line.
list_ver_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each vertical line.
Returns
-------
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
"""
(list_coef_hor, list_hor_lines) = _para_fit_hor(list_hor_lines, 0.0, 0.0)
(list_coef_ver, list_ver_lines) = _para_fit_ver(list_ver_lines, 0.0, 0.0)
pos_hor = np.argmax(np.abs(np.diff(np.sign(list_coef_hor[:, 0])))) + 1
pos_ver = np.argmax(np.abs(np.diff(np.sign(list_coef_ver[:, 0])))) + 1
ycenter0 = (list_coef_hor[pos_hor - 1, 2] + list_coef_hor[
pos_hor, 2]) * 0.5
xcenter0 = (list_coef_ver[pos_ver - 1, 2] + list_coef_ver[
pos_ver, 2]) * 0.5
slope_hor = (list_coef_hor[pos_hor - 1, 1] + list_coef_hor[
pos_hor, 1]) * 0.5
slope_ver = (list_coef_ver[pos_ver - 1, 1] + list_coef_ver[
pos_ver, 1]) * 0.5
ycenter = (ycenter0 + xcenter0 * slope_hor) / (1.0 - slope_hor * slope_ver)
xcenter = (xcenter0 + ycenter0 * slope_ver) / (1.0 - slope_hor * slope_ver)
return xcenter, ycenter
def _func_dist(x, a, b, c):
"""
Function for finding the minimum distance.
"""
return x ** 2 + (a * x ** 2 + b * x + c) ** 2
def _calc_error(list_coef_hor, list_coef_ver):
"""
Calculate a metric of measuring how close fitted lines to the coordinate
origin by: locating points on each parabola having the minimum distance
to the origin, applying linear fits to these points, adding intercepts of
the fits.
Parameters
----------
list_coef_hor : list of 1D arrays
Coefficients of parabolic fits of horizontal lines.
list_coef_ver : list of 1D arrays
Coefficients of parabolic fits of vertical lines.
Returns
-------
float
"""
num_hline = len(list_coef_hor)
num_vline = len(list_coef_ver)
list_hpoint = np.zeros((num_hline, 2), dtype=np.float32)
for i, coefs in enumerate(list_coef_hor):
minimum = optimize.minimize(_func_dist, 0.0, args=tuple(coefs))
xm = minimum.x[0]
ym = coefs[0] * xm ** 2 + coefs[1] * xm + coefs[2]
list_hpoint[i, 0] = xm
list_hpoint[i, 1] = ym
list_vpoint = np.zeros((num_vline, 2), dtype=np.float32)
for i, coefs in enumerate(list_coef_ver):
minimum = optimize.minimize(_func_dist, 0.0, args=tuple(coefs))
ym = minimum.x[0]
xm = coefs[0] * ym ** 2 + coefs[1] * ym + coefs[2]
list_vpoint[i, 0] = ym
list_vpoint[i, 1] = xm
error_h = np.polyfit(list_hpoint[:, 0], list_hpoint[:, 1], 1)[-1]
error_v = np.polyfit(list_vpoint[:, 0], list_vpoint[:, 1], 1)[-1]
return np.abs(error_h) + np.abs(error_v)
def _calc_metric(list_hor_lines, list_ver_lines, xcenter, ycenter,
list_xshift, list_yshift):
"""
Calculate a metric for determining the best center of distortion.
Parameters
----------
list_hor_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each horizontal line.
list_ver_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each vertical line.
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
list_xshift : list of float
List of x-offsets from the x-center.
list_yshift : list of float
List of y-offsets from the y-center.
Returns
-------
xshift : float
Shift in x-direction from the x-center.
yshift : float
Shift in y-direction from the y-center.
"""
(list_coef_hor, list_hor_lines) = _para_fit_hor(
list_hor_lines, xcenter, ycenter)
(list_coef_ver, list_ver_lines) = _para_fit_ver(
list_ver_lines, xcenter, ycenter)
pos_hor = np.argmin(np.abs(list_coef_hor[:, 2]))
pos_ver = np.argmin(np.abs(list_coef_ver[:, 2]))
mat_metric = np.zeros(
(len(list_xshift), len(list_yshift)), dtype=np.float32)
num_hline = len(list_hor_lines)
num_vline = len(list_ver_lines)
numuse = min(5, num_hline // 2 - 1, num_vline // 2 - 1)
(posh1, posh2) = (
max(0, pos_hor - numuse), min(num_hline, pos_hor + numuse + 1))
(posv1, posv2) = (
max(0, pos_ver - numuse), min(num_vline, pos_ver + numuse + 1))
for j, pos_x in enumerate(list_xshift):
for i, pos_y in enumerate(list_yshift):
(list_coef_hor, _) = _para_fit_hor(
list_hor_lines[posh1:posh2], pos_x, pos_y)
(list_coef_ver, _) = _para_fit_ver(
list_ver_lines[posv1:posv2], pos_x, pos_y)
mat_metric[i, j] = _calc_error(list_coef_hor, list_coef_ver)
min_pos = (np.unravel_index(mat_metric.argmin(), mat_metric.shape))
xshift = list_xshift[min_pos[1]]
yshift = list_yshift[min_pos[0]]
return xshift, yshift
def find_cod_fine(list_hor_lines, list_ver_lines, xcenter, ycenter, dot_dist):
"""
Find the best center of distortion (CoD) by searching around the coarse
estimation of the CoD.
Parameters
----------
list_hor_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each horizontal line.
list_ver_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each vertical line.
xcenter : float
Coarse estimation of the CoD in x-direction.
ycenter : float
Coarse estimation of the CoD in y-direction.
dot_dist : float
Median distance of two nearest dots.
Returns
-------
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
"""
step0 = 2.0
list_xshift = np.arange(-dot_dist, dot_dist + step0, step0)
list_yshift = list_xshift
(xshift, yshift) = _calc_metric(
list_hor_lines, list_ver_lines, xcenter, ycenter, list_xshift,
list_yshift)
xcenter1 = xcenter + xshift
ycenter1 = ycenter + yshift
step = 0.5
list_xshift = np.arange(-step0, step0 + step, step)
list_yshift = list_xshift
(xshift, yshift) = _calc_metric(
list_hor_lines, list_ver_lines, xcenter1, ycenter1, list_xshift,
list_yshift)
xcenter2 = xcenter1 + xshift
ycenter2 = ycenter1 + yshift
return xcenter2, ycenter2
def _check_missing_lines(list_coef_hor, list_coef_ver):
"""
Check if there are missing lines
Parameters
----------
list_coef_hor : list of 1D arrays
Coefficients of parabolic fits of horizontal lines.
list_coef_ver : list of 1D arrays
Coefficients of parabolic fits of vertical lines.
Returns
-------
bool
"""
check = False
list_dist_hor = np.abs(np.diff(list_coef_hor[:, 2]))
list_dist_ver = np.abs(np.diff(list_coef_ver[:, 2]))
list_hindex = np.arange(len(list_dist_hor))
list_vindex = np.arange(len(list_dist_ver))
hfact = np.polyfit(list_hindex, list_dist_hor, 2)
vfact = np.polyfit(list_vindex, list_dist_ver, 2)
list_fit_hor = hfact[0] * list_hindex ** 2 + \
hfact[1] * list_hindex + hfact[2]
list_fit_ver = vfact[0] * list_vindex ** 2 + \
vfact[1] * list_vindex + vfact[2]
herror = np.max(np.abs((list_dist_hor - list_fit_hor) / list_fit_hor))
verror = np.max(np.abs((list_dist_ver - list_fit_ver) / list_fit_ver))
if (herror > 0.3) or (verror > 0.3):
check = True
return check
def _func_opt(d0, c0, indexc0, *list_inter):
"""
Function for finding the optimum undistorted distance for radial
distortion correction.
"""
return np.sum(
np.asarray([(np.sign(c) * np.abs(i - indexc0) * d0 + c0 - c) ** 2
for i, c in enumerate(list_inter)]))
def _optimize_intercept(dist_hv, pos_hv, list_inter):
"""
Find the optimum undistorted distance for radial-distortion correction.
"""
list_arg = [list_inter[pos_hv], pos_hv]
list_arg.extend(list_inter)
minimum = optimize.minimize(_func_opt, dist_hv, args=tuple(list_arg))
return minimum.x[0]
def _calc_undistor_intercept(list_hor_lines, list_ver_lines, xcenter, ycenter,
optimizing=False):
"""
Calculate the intercepts of undistorted lines.
Parameters
----------
list_hor_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each horizontal line.
list_ver_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each vertical line.
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
optimizing : bool, optional
Apply optimization if True.
Returns
-------
list_hor_uc : list of floats
Intercepts of undistorted horizontal lines.
list_ver_uc : list of floats
Intercepts of undistorted vertical lines.
"""
(list_coef_hor, list_hor_lines) = _para_fit_hor(
list_hor_lines, xcenter, ycenter)
(list_coef_ver, list_ver_lines) = _para_fit_ver(
list_ver_lines, xcenter, ycenter)
check = _check_missing_lines(list_coef_hor, list_coef_ver)
if check:
print("!!! ERROR !!!")
print("Parameters of the methods of grouping dots need to be adjusted")
raise ValueError("There're missing lines, algorithm will not work!!!")
pos_hor = np.argmin(np.abs(list_coef_hor[:, 2]))
pos_ver = np.argmin(np.abs(list_coef_ver[:, 2]))
num_hline = len(list_hor_lines)
num_vline = len(list_ver_lines)
num_use = min(3, num_hline // 2 - 1, num_vline // 2 - 1)
(posh1, posh2) = (
max(0, pos_hor - num_use), min(num_hline, pos_hor + num_use + 1))
(posv1, posv2) = (
max(0, pos_ver - num_use), min(num_vline, pos_ver + num_use + 1))
dist_hor = np.mean(np.abs(np.diff(list_coef_hor[posh1: posh2, 2])))
dist_ver = np.mean(np.abs(np.diff(list_coef_ver[posv1: posv2, 2])))
if optimizing is True:
dist_hor = _optimize_intercept(dist_hor, pos_hor, list_coef_hor[:, 2])
dist_ver = _optimize_intercept(dist_ver, pos_ver, list_coef_ver[:, 2])
list_hor_uc = np.zeros(num_hline, dtype=np.float32)
list_ver_uc = np.zeros(num_vline, dtype=np.float32)
for i in range(num_hline):
dist = np.abs(i - pos_hor) * dist_hor
list_hor_uc[i] = np.sign(list_coef_hor[i, 2]) * dist + list_coef_hor[
pos_hor, 2]
for i in range(num_vline):
dist = np.abs(i - pos_ver) * dist_ver
list_ver_uc[i] = np.sign(list_coef_ver[i, 2]) * dist + list_coef_ver[
pos_ver, 2]
return list_hor_uc, list_ver_uc
def calc_coef_backward(list_hor_lines, list_ver_lines, xcenter, ycenter,
num_fact):
"""
Calculate the distortion coefficients of a backward mode.
Parameters
----------
list_hor_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each horizontal line.
list_ver_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each vertical line.
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
num_fact : int
Number of the factors of polynomial.
Returns
-------
list_fact : list of float
Coefficients of the polynomial.
"""
num_fact = np.int16(np.clip(num_fact, 1, None))
(list_hor_uc, list_ver_uc) = _calc_undistor_intercept(
list_hor_lines, list_ver_lines, xcenter, ycenter)
(list_coef_hor, list_hor_lines) = _para_fit_hor(
list_hor_lines, xcenter, ycenter)
(list_coef_ver, list_ver_lines) = _para_fit_ver(
list_ver_lines, xcenter, ycenter)
Amatrix = []
Bmatrix = []
list_expo = np.arange(num_fact, dtype=np.int16)
for i, line in enumerate(list_hor_lines):
(a_coef, _, c_coef) = np.float64(list_coef_hor[i])
uc_coef = np.float64(list_hor_uc[i])
for _, point in enumerate(line):
xd = np.float64(point[1])
yd = np.float64(point[0])
rd = np.sqrt(xd * xd + yd * yd)
Fb = (a_coef * xd * xd + c_coef) / uc_coef
Amatrix.append(np.power(rd / Fb, list_expo))
Bmatrix.append(Fb)
for i, line in enumerate(list_ver_lines):
(a_coef, _, c_coef) = np.float64(list_coef_ver[i])
uc_coef = np.float64(list_ver_uc[i])
for _, point in enumerate(line):
xd = np.float64(point[1])
yd = np.float64(point[0])
rd = np.sqrt(xd * xd + yd * yd)
Fb = (a_coef * yd * yd + c_coef) / uc_coef
Amatrix.append(np.power(rd / Fb, list_expo))
Bmatrix.append(Fb)
Amatrix = np.asarray(Amatrix, dtype=np.float64)
Bmatrix = np.asarray(Bmatrix, dtype=np.float64)
list_fact = np.linalg.lstsq(Amatrix, Bmatrix, rcond=1e-64)[0]
return list_fact
def calc_coef_forward(list_hor_lines, list_ver_lines, xcenter, ycenter,
num_fact):
"""
Calculate the distortion coefficients of a forward mode.
Parameters
----------
list_hor_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each horizontal line.
list_ver_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each vertical line.
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
num_fact : int
Number of the factors of polynomial.
Returns
-------
list_fact : list of float
Coefficients of the polynomial.
"""
num_fact = np.int16(np.clip(num_fact, 1, None))
(list_hor_uc, list_ver_uc) = _calc_undistor_intercept(
list_hor_lines, list_ver_lines, xcenter, ycenter)
(list_coef_hor, list_hor_lines) = _para_fit_hor(
list_hor_lines, xcenter, ycenter)
(list_coef_ver, list_ver_lines) = _para_fit_ver(
list_ver_lines, xcenter, ycenter)
list_expo = np.arange(num_fact, dtype=np.int16)
Amatrix = []
Bmatrix = []
for i, line in enumerate(list_hor_lines):
(a_coef, _, c_coef) = np.float64(list_coef_hor[i])
uc_coef = np.float64(list_hor_uc[i])
if uc_coef != 0.0:
for _, point in enumerate(line):
xd = np.float64(point[1])
yd = np.float64(point[0])
rd = np.sqrt(xd * xd + yd * yd)
Fb = uc_coef / (a_coef * xd * xd + c_coef)
if Fb != 0.0:
Amatrix.append(np.power(rd, list_expo))
Bmatrix.append(Fb)
for i, line in enumerate(list_ver_lines):
(a_coef, _, c_coef) = np.float64(list_coef_ver[i])
uc_coef = np.float64(list_ver_uc[i])
if uc_coef != 0.0:
for _, point in enumerate(line):
xd = np.float64(point[1])
yd = np.float64(point[0])
rd = np.sqrt(xd * xd + yd * yd)
Fb = uc_coef / (a_coef * yd * yd + c_coef)
if Fb != 0.0:
Amatrix.append(np.power(rd, list_expo))
Bmatrix.append(Fb)
Amatrix = np.asarray(Amatrix, dtype=np.float64)
Bmatrix = np.asarray(Bmatrix, dtype=np.float64)
list_fact = np.linalg.lstsq(Amatrix, Bmatrix, rcond=1e-64)[0]
return list_fact
def calc_coef_backward_from_forward(list_hor_lines, list_ver_lines, xcenter,
ycenter, num_fact):
"""
Calculate the distortion coefficients of a backward mode from a forward
model.
Parameters
----------
list_hor_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each horizontal line.
list_ver_lines : list of 2D arrays
List of the (y,x)-coordinates of dot-centroids on each vertical line.
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
num_fact : int
Number of the factors of polynomial.
Returns
-------
list_ffact : list of floats
Polynomial coefficients of the forward model.
list_bfact : list of floats
Polynomial coefficients of the backward model.
"""
num_fact = np.int16(np.clip(num_fact, 1, None))
list_ffact = np.float64(
calc_coef_forward(list_hor_lines, list_ver_lines, xcenter, ycenter,
num_fact))
(_, list_hor_lines) = _para_fit_hor(list_hor_lines, xcenter, ycenter)
(_, list_ver_lines) = _para_fit_ver(list_ver_lines, xcenter, ycenter)
list_expo = np.arange(num_fact, dtype=np.int16)
Amatrix = []
Bmatrix = []
for _, line in enumerate(list_hor_lines):
for _, point in enumerate(line):
xd = np.float64(point[1])
yd = np.float64(point[0])
rd = np.sqrt(xd * xd + yd * yd)
ffactor = np.float64(np.sum(list_ffact * np.power(rd, list_expo)))
if ffactor != 0.0:
Fb = 1 / ffactor
ru = ffactor * rd
Amatrix.append(np.power(ru, list_expo))
Bmatrix.append(Fb)
for _, line in enumerate(list_ver_lines):
for _, point in enumerate(line):
xd = np.float64(point[1])
yd = np.float64(point[0])
rd = np.sqrt(xd * xd + yd * yd)
ffactor = np.float64(np.sum(list_ffact * np.power(rd, list_expo)))
if ffactor != 0.0:
Fb = 1 / ffactor
ru = ffactor * rd
Amatrix.append(np.power(ru, list_expo))
Bmatrix.append(Fb)
Amatrix = np.asarray(Amatrix, dtype=np.float64)
Bmatrix = np.asarray(Bmatrix, dtype=np.float64)
list_bfact = np.linalg.lstsq(Amatrix, Bmatrix, rcond=1e-64)[0]
return list_ffact, list_bfact
def transform_coef_backward_and_forward(list_fact, mapping="backward",
ref_points=None):
"""
Transform polynomial coefficients of a radial distortion model between
forward mapping and backward mapping.
Parameters
----------
list_fact : list of floats
Polynomial coefficients of the radial distortion model.
mapping : {'backward', 'forward'}
Transformation direction.
ref_points : list of 1D-arrays, optional
List of the (y,x)-coordinates of points used for the transformation.
Generated if None given.
Returns
-------
list of floats
Polynomial coefficients of the reversed model.
"""
if ref_points is None:
ref_points = [[i, j] for i in np.arange(-1000, 1000, 50) for j in
np.arange(-1000, 1000, 50)]
else:
num_points = len(ref_points)
if num_points < len(list_fact):
raise ValueError("Number of reference-points must be equal or "
"larger than the number of coefficients!!!")
Amatrix = []
Bmatrix = []
list_expo = np.arange(len(list_fact), dtype=np.int16)
if mapping == "forward":
for point in ref_points:
xu = np.float64(point[1])
yu = np.float64(point[0])
ru = np.sqrt(xu * xu + yu * yu)
factor = np.float64(
np.sum(list_fact * np.power(ru, list_expo)))
if factor != 0.0:
Fb = 1 / factor
rd = factor * ru
Amatrix.append(np.power(rd, list_expo))
Bmatrix.append(Fb)
else:
for point in ref_points:
xd = np.float64(point[1])
yd = np.float64(point[0])
rd = np.sqrt(xd * xd + yd * yd)
factor = np.float64(
np.sum(list_fact * np.power(rd, list_expo)))
if factor != 0.0:
Fb = 1 / factor
ru = factor * rd
Amatrix.append(np.power(ru, list_expo))
Bmatrix.append(Fb)
Amatrix = np.asarray(Amatrix, dtype=np.float64)
Bmatrix = np.asarray(Bmatrix, dtype=np.float64)
trans_fact = np.linalg.lstsq(Amatrix, Bmatrix, rcond=1e-64)[0]
return trans_fact
def find_cod_bailey(list_hor_lines, list_ver_lines, iteration=2):
"""
Find the center of distortion (COD) using the Bailey's approach (Ref. [1]).
Parameters
----------
list_hor_lines : list of 2D-arrays
List of the (y,x)-coordinates of points on each horizontal line.
list_ver_lines : list of 2D-arrays
List of the (y,x)-coordinates of points on each vertical line.
Returns
-------
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
References
----------
[1].. https://www-ist.massey.ac.nz/dbailey/sprg/pdfs/2002_IVCNZ_59.pdf
"""
(xcenter, ycenter) = find_cod_coarse(list_hor_lines, list_ver_lines)
list_coef_hor = _para_fit_hor(list_hor_lines, xcenter, ycenter)[0]
list_coef_ver = _para_fit_ver(list_ver_lines, xcenter, ycenter)[0]
a1, b1 = np.polyfit(list_coef_hor[:, 2], list_coef_hor[:, 0], 1)[0:2]
a2, b2 = np.polyfit(list_coef_ver[:, 2], list_coef_ver[:, 0], 1)[0:2]
xcenter = xcenter - b2 / a2
ycenter = ycenter - b1 / a1
for i in range(iteration):
list_coef_hor = _para_fit_hor(list_hor_lines, xcenter, ycenter)[0]
list_coef_ver = _para_fit_ver(list_ver_lines, xcenter, ycenter)[0]
a1, b1 = np.polyfit(list_coef_hor[:, 2], list_coef_hor[:, 0], 1)[0:2]
a2, b2 = np.polyfit(list_coef_ver[:, 2], list_coef_ver[:, 0], 1)[0:2]
xcenter = xcenter - b2 / a2
ycenter = ycenter - b1 / a1
return xcenter, ycenter
def _generate_non_perspective_parabola_coef(list_hor_lines, list_ver_lines):
"""
Correct the deviation of fitted parabola coefficients of each line caused
by perspective distortion. Note that the resulting coefficients are
referred to a different origin-coordinate instead of (0, 0).
Parameters
----------
list_hor_lines : list of 2D-arrays
List of the (y,x)-coordinates of points on each horizontal line.
list_ver_lines : list of 2D-arrays
List of the (y,x)-coordinates of points on each vertical line.
Returns
-------
list_coef_hor : list of 1D-arrays
List of the corrected coefficients for horizontal lines.
list_coef_ver : list of 1D-arrays
List of the corrected coefficients for vertical lines.
xcenter : float
Center of distortion in x-direction.
ycenter : float
Center of distortion in y-direction.
"""
num_hline, num_vline = len(list_hor_lines), len(list_ver_lines)
xcenter, ycenter = find_cod_bailey(list_hor_lines, list_ver_lines)
list_coef_hor = _para_fit_hor(list_hor_lines, xcenter, ycenter)[0]
list_coef_ver = _para_fit_ver(list_ver_lines, xcenter, ycenter)[0]
ah, bh = np.polyfit(list_coef_hor[:, 2], list_coef_hor[:, 1], 1)[0:2]
av, bv = np.polyfit(list_coef_ver[:, 2], -list_coef_ver[:, 1], 1)[0:2]
if np.abs(ah - av) >= 0.001:
b0 = (ah * bv - av * bh) / (ah - av)
else:
b0 = (bh + bv) * 0.5
list_coef_hor[:, 1] = b0 * np.ones(num_hline)
list_coef_ver[:, 1] = -b0 * np.ones(num_vline)
pos_hor = np.argmax(np.abs(np.diff(np.sign(list_coef_hor[:, 0])))) + 1
pos_ver = np.argmax(np.abs(np.diff(np.sign(list_coef_ver[:, 0])))) + 1
num_use = min(3, num_hline // 2 - 1, num_vline // 2 - 1)
(posh1, posh2) = (
max(0, pos_hor - num_use), min(num_hline, pos_hor + num_use + 1))
(posv1, posv2) = (
max(0, pos_ver - num_use), min(num_vline, pos_ver + num_use + 1))
dist_hor = np.mean(np.abs(np.diff(list_coef_hor[posh1: posh2, 2])))
dist_ver = np.mean(np.abs(np.diff(list_coef_ver[posv1: posv2, 2])))
if dist_hor > dist_ver:
list_coef_ver[:, 2] = list_coef_ver[:, 2] * dist_hor / dist_ver
list_coef_ver[:, 0] = list_coef_ver[:, 0] * dist_hor / dist_ver
else:
list_coef_hor[:, 2] = list_coef_hor[:, 2] * dist_ver / dist_hor
list_coef_hor[:, 0] = list_coef_hor[:, 0] * dist_ver / dist_hor
return list_coef_hor, list_coef_ver, xcenter, ycenter
def _find_cross_point_between_parabolas(para_coef_hor, para_coef_ver):
"""
Find a cross point between two parabolas.
Parameters
----------
para_coef_hor : array_like
Coefficients of a horizontal parabola (y=ax**2+bx+c).
para_coef_ver : array_like
Coefficients of a vertical parabola (x=ay**2+by+c).
Returns
-------
x, y : floats
Coordinate of the cross point.
"""
a1, b1, c1 = para_coef_hor[0:3]
a2, b2, c2 = para_coef_ver[0:3]
xvals = np.float32(np.real(
np.roots([a1 ** 2 * a2, 2 * a1 * a2 * b1,
a2 * b1 ** 2 + a1 * b2 + 2 * a1 * a2 * c1,
-1 + b1 * b2 + 2 * a2 * b1 * c1,
b2 * c1 + a2 * c1 ** 2 + c2])))
if len(xvals) == 0:
raise ValueError("Can't find a cross point between two parabolas")
if len(xvals) > 1:
x = xvals[np.argmin(np.abs(xvals - c2))]
else:
x = xvals[0]
y = a1 * x ** 2 + b1 * x + c1
return x, y
def regenerate_grid_points_parabola(list_hor_lines, list_ver_lines,
perspective=True):
"""
Regenerating grid points by finding cross points between horizontal lines
and vertical lines using their parabola coefficients.
Parameters
----------
list_hor_lines : list of 2D-arrays
List of the (y,x)-coordinates of points on each horizontal line.
list_ver_lines : list of 2D-arrays
List of the (y,x)-coordinates of points on each vertical line.
perspective : bool, optional
Apply perspective correction if True.
Returns
-------
new_hor_lines : list of 2D-arrays
List of the updated (y,x)-coordinates of points on each horizontal
line.
new_ver_lines : list of 2D-arrays
List of the updated (y,x)-coordinates of points on each vertical line.
"""
if perspective is True:
results = _generate_non_perspective_parabola_coef(list_hor_lines,
list_ver_lines)
list_coef_hor, list_coef_ver, xcenter, ycenter = results
else:
xcenter, ycenter = find_cod_bailey(list_hor_lines, list_ver_lines)
list_coef_hor = _para_fit_hor(list_hor_lines, xcenter, ycenter)[0]
list_coef_ver = _para_fit_ver(list_ver_lines, xcenter, ycenter)[0]
num_hline, num_vline = len(list_coef_hor), len(list_coef_ver)
new_hor_lines = np.zeros((num_hline, num_vline, 2), dtype=np.float32)
new_ver_lines = np.zeros((num_vline, num_hline, 2), dtype=np.float32)
for i in range(num_hline):
for j in range(num_vline):
x, y = _find_cross_point_between_parabolas(list_coef_hor[i],
list_coef_ver[j])
new_hor_lines[i, j] = np.asarray([y + ycenter, x + xcenter])
new_ver_lines[j, i] = np.asarray([y + ycenter, x + xcenter])
return new_hor_lines, new_ver_lines
def _generate_linear_coef(list_hor_lines, list_ver_lines, xcenter=0.0,
ycenter=0.0):
"""
Get linear coefficients of horizontal and vertical lines from linear fit.
Parameters
----------
list_hor_lines : list of 2D-arrays
List of the (y,x)-coordinates of points on each horizontal line.
list_ver_lines : list of 2D-arrays
List of the (y,x)-coordinates of points on each vertical line.
xcenter : float
X-origin of the coordinate system.
ycenter : float
Y-origin of the coordinate system.
Returns
-------
list_coef_hor : list of 1D-arrays
List of the linear coefficients for horizontal lines.
list_coef_ver : list of 1D-arrays
List of the linear coefficients for vertical lines.
"""
num_hline, num_vline = len(list_hor_lines), len(list_ver_lines)
list_coef_hor = | np.zeros((num_hline, 2), dtype=np.float32) | numpy.zeros |
from numpy import concatenate, zeros
from scipy.linalg import toeplitz
import torch
from torch import nn
import numpy as np
import matplotlib as mat
mat.use("TkAgg")
import matplotlib.pyplot as plt
import time
from torch.autograd import Variable
import cv2
torch.manual_seed(1) # reproducible
mat.use("TkAgg")
hidden_siz = 30
hidden_lay = 1
LR = 0.02 # learning rate
class LSNN1(nn.Module):
def __init__(self):
super(LSNN1, self).__init__()
self.lstm = nn.LSTM(
input_size=1,
hidden_size=hidden_siz,
num_layers=hidden_lay,
batch_first=True,
)
self.hidden = (torch.autograd.Variable(torch.zeros(hidden_lay, 1, hidden_siz)),torch.autograd.Variable(torch.zeros(hidden_lay, 1, hidden_siz)))
self.out = nn.Linear(hidden_siz, 1)
def forward(self,x):
# x (batch, time_step, input_size)
# h_state (n_layers, batch, hidden_size)
# r_out (batch, time_step, output_size)
r_out,self.hidden= self.lstm(x,self.hidden)
self.hidden=(Variable(self.hidden[0]),Variable(self.hidden[1]))
outs = []
#print(r_out.size())
for time_step in range(33):
outs.append(self.out(r_out[:, time_step, :]))
return torch.stack(outs, dim=1)
class LSNN2(nn.Module):
def __init__(self):
super(LSNN2, self).__init__()
self.lstm = nn.LSTM(
input_size=1,
hidden_size=hidden_siz,
num_layers=hidden_lay,
batch_first=True,
)
self.hidden = (torch.autograd.Variable(torch.zeros(hidden_lay, 1, hidden_siz)),torch.autograd.Variable(torch.zeros(hidden_lay, 1, hidden_siz)))
self.out = nn.Linear(hidden_siz, 1)
def forward(self,x):
# x (batch, time_step, input_size)
# h_state (n_layers, batch, hidden_size)
# r_out (batch, time_step, output_size)
r_out,self.hidden= self.lstm(x,self.hidden)
self.hidden=(Variable(self.hidden[0]),Variable(self.hidden[1]))
outs = []
for time_step in range(100):
if(time_step>=33 and time_step<66):
outs.append(self.out(r_out[:, time_step, :]))
return torch.stack(outs, dim=1)
class LSNN3(nn.Module):
def __init__(self):
super(LSNN3, self).__init__()
self.lstm = nn.LSTM(
input_size=1,
hidden_size=hidden_siz,
num_layers=hidden_lay,
batch_first=True,
)
self.hidden = (torch.autograd.Variable(torch.zeros(hidden_lay, 1, hidden_siz)),torch.autograd.Variable(torch.zeros(hidden_lay, 1, hidden_siz)))
self.out = nn.Linear(hidden_siz, 1)
def forward(self,x):
# x (batch, time_step, input_size)
# h_state (n_layers, batch, hidden_size)
# r_out (batch, time_step, output_size)
r_out,self.hidden= self.lstm(x,self.hidden)
self.hidden=(Variable(self.hidden[0]),Variable(self.hidden[1]))
outs = []
for time_step in range(67):
if(time_step>=33 and time_step<67):
outs.append(self.out(r_out[:, time_step, :]))
return torch.stack(outs, dim=1)
lstmNN1 = LSNN1()
lstmNN2 = LSNN2()
lstmNN3 = LSNN3()
optimizer1 = torch.optim.Adam(lstmNN1.parameters(), lr=LR) # optimize all rnn parameters
optimizer2 = torch.optim.Adam(lstmNN2.parameters(), lr=LR)
optimizer3 = torch.optim.Adam(lstmNN3.parameters(), lr=LR)
loss_func = nn.MSELoss()
loss_list1 = []
loss_list2 = []
loss_list3 = []
prediction_list1 = []
prediction_list2 = []
prediction_list3 = []
steps = np.linspace(0, 100, 100, dtype=np.float32)
for step in range(98):
if step == 0:
x_np1 = toeplitz(concatenate([[1.], zeros(99)]),concatenate([[1.,1.,1.], zeros(97)]))[step: step + 1, :33]
x_np2 = toeplitz(concatenate([[1.], zeros(99)]),concatenate([[1.,1.,1.], zeros(97)]))[step: step + 1, 33: 66]
x_np3 = toeplitz(concatenate([[1.], zeros(99)]),concatenate([[1.,1.,1.], zeros(97)]))[step: step + 1, 66:]
y_np1 = toeplitz(concatenate([[1.], zeros(99)]),concatenate([[1.,1.,1.], zeros(97)]))[step + 1: step + 2, :33]
y_np2 = toeplitz(concatenate([[1.], zeros(99)]),concatenate([[1.,1.,1.], | zeros(97) | numpy.zeros |
import os
from os.path import join as pjoin
import numpy as np
import pandas as pd
import scipy.stats
import dask
from cesium import featurize
from cesium.tests.fixtures import (sample_values, sample_ts_files,
sample_featureset)
import numpy.testing as npt
import pytest
DATA_PATH = pjoin(os.path.dirname(__file__), "data")
FEATURES_CSV_PATH = pjoin(DATA_PATH, "test_features_with_targets.csv")
def test_featurize_files_function(tmpdir):
"""Test featurize function for on-disk time series"""
with sample_ts_files(size=4, labels=['A', 'B']) as ts_paths:
fset, labels = featurize.featurize_ts_files(ts_paths,
features_to_use=["std_err"],
scheduler=dask.get)
assert "std_err" in fset
assert fset.shape == (4, 1)
npt.assert_array_equal(labels, ['A', 'B', 'A', 'B'])
def test_featurize_time_series_single():
"""Test featurize wrapper function for single time series"""
t, m, e = sample_values()
features_to_use = ['amplitude', 'std_err']
meta_features = {'meta1': 0.5}
fset = featurize.featurize_time_series(t, m, e, features_to_use,
meta_features, scheduler=dask.get)
assert fset['amplitude'].values.dtype == np.float64
def test_featurize_time_series_single_multichannel():
"""Test featurize wrapper function for single multichannel time series"""
n_channels = 3
t, m, e = sample_values(channels=n_channels)
features_to_use = ['amplitude', 'std_err']
meta_features = {'meta1': 0.5}
fset = featurize.featurize_time_series(t, m, e, features_to_use,
meta_features, scheduler=dask.get)
assert ('amplitude', 0) in fset.columns
assert 'meta1' in fset.columns
def test_featurize_time_series_multiple():
"""Test featurize wrapper function for multiple time series"""
n_series = 5
list_of_series = [sample_values() for i in range(n_series)]
times, values, errors = [list(x) for x in zip(*list_of_series)]
features_to_use = ['amplitude', 'std_err']
meta_features = [{'meta1': 0.5}] * n_series
fset = featurize.featurize_time_series(times, values, errors,
features_to_use,
meta_features, scheduler=dask.get)
npt.assert_array_equal(sorted(fset.columns.get_level_values('feature')),
['amplitude', 'meta1', 'std_err'])
def test_featurize_time_series_multiple_multichannel():
"""Test featurize wrapper function for multiple multichannel time series"""
n_series = 5
n_channels = 3
list_of_series = [sample_values(channels=n_channels)
for i in range(n_series)]
times, values, errors = [list(x) for x in zip(*list_of_series)]
features_to_use = ['amplitude', 'std_err']
meta_features = {'meta1': 0.5}
fset = featurize.featurize_time_series(times, values, errors,
features_to_use,
meta_features, scheduler=dask.get)
assert ('amplitude', 0) in fset.columns
assert 'meta1' in fset.columns
def test_featurize_time_series_uneven_multichannel():
"""Test featurize wrapper function for uneven-length multichannel data"""
n_channels = 3
t, m, e = sample_values(channels=n_channels)
t = [[t, t[0:-5], t[0:-10]]]
m = [[m[0], m[1][0:-5], m[2][0:-10]]]
e = [[e[0], e[1][0:-5], e[2][0:-10]]]
features_to_use = ['amplitude', 'std_err']
meta_features = {'meta1': 0.5}
fset = featurize.featurize_time_series(t, m, e, features_to_use,
meta_features, scheduler=dask.get)
assert ('amplitude', 0) in fset.columns
assert 'meta1' in fset.columns
def test_featurize_time_series_custom_functions():
"""Test featurize wrapper function for time series w/ custom functions"""
n_channels = 3
t, m, e = sample_values(channels=n_channels)
features_to_use = ['amplitude', 'std_err', 'test_f']
meta_features = {'meta1': 0.5}
custom_functions = {'test_f': lambda t, m, e: np.pi}
fset = featurize.featurize_time_series(t, m, e, features_to_use,
meta_features,
custom_functions=custom_functions,
scheduler=dask.get)
npt.assert_array_equal(fset['test_f', 0], np.pi)
assert ('amplitude', 0) in fset.columns
assert 'meta1' in fset.columns
def test_featurize_time_series_custom_dask_graph():
"""Test featurize wrapper function for time series w/ custom dask graph"""
n_channels = 3
t, m, e = sample_values(channels=n_channels)
features_to_use = ['amplitude', 'std_err', 'test_f', 'test_meta']
meta_features = {'meta1': 0.5}
custom_functions = {'test_f': (lambda x: x.min() - x.max(), 'amplitude'),
'test_meta': (lambda x: 2. * x, 'meta1')}
fset = featurize.featurize_time_series(t, m, e, features_to_use,
meta_features,
custom_functions=custom_functions,
scheduler=dask.get)
assert ('amplitude', 0) in fset.columns
assert ('test_f', 0) in fset.columns
assert ('test_meta', 0) in fset.columns
def test_featurize_time_series_default_times():
"""Test featurize wrapper function for time series w/ missing times"""
n_channels = 3
_, m, e = sample_values(channels=n_channels)
features_to_use = ['amplitude', 'std_err']
meta_features = {}
fset = featurize.featurize_time_series(None, m, e, features_to_use,
meta_features, scheduler=dask.get)
m = [[m[0], m[1][0:-5], m[2][0:-10]]]
e = [[e[0], e[1][0:-5], e[2][0:-10]]]
fset = featurize.featurize_time_series(None, m, e, features_to_use,
meta_features, scheduler=dask.get)
m = m[0][0]
e = e[0][0]
fset = featurize.featurize_time_series(None, m, e, features_to_use,
meta_features, scheduler=dask.get)
assert ('amplitude', 0) in fset.columns
def test_featurize_time_series_default_errors():
"""Test featurize wrapper function for time series w/ missing errors"""
n_channels = 3
t, m, _ = sample_values(channels=n_channels)
features_to_use = ['amplitude', 'std_err']
meta_features = {}
fset = featurize.featurize_time_series(t, m, None, features_to_use,
meta_features, scheduler=dask.get)
t = [[t, t[0:-5], t[0:-10]]]
m = [[m[0], m[1][0:-5], m[2][0:-10]]]
fset = featurize.featurize_time_series(t, m, None, features_to_use,
meta_features, scheduler=dask.get)
t = t[0][0]
m = m[0][0]
fset = featurize.featurize_time_series(t, m, None, features_to_use,
meta_features, scheduler=dask.get)
assert ('amplitude', 0) in fset.columns
def test_featurize_time_series_pandas_metafeatures():
"""Test featurize function for metafeatures passed as Series/DataFrames."""
t, m, e = sample_values()
features_to_use = ['amplitude', 'std_err']
meta_features = pd.Series({'meta1': 0.5})
fset = featurize.featurize_time_series(t, m, e, features_to_use,
meta_features, scheduler=dask.get)
npt.assert_allclose(fset['meta1'], 0.5)
n_series = 5
list_of_series = [sample_values() for i in range(n_series)]
times, values, errors = [list(x) for x in zip(*list_of_series)]
features_to_use = ['amplitude', 'std_err']
meta_features = pd.DataFrame({'meta1': [0.5] * n_series,
'meta2': [0.8] * n_series})
fset = featurize.featurize_time_series(times, values, errors,
features_to_use,
meta_features, scheduler=dask.get)
npt.assert_allclose(fset['meta1'], 0.5)
npt.assert_allclose(fset['meta2'], 0.8)
def test_impute():
"""Test imputation of missing Featureset values."""
fset, labels = sample_featureset(5, 1, ['amplitude'], ['class1', 'class2'],
names=['a', 'b', 'c', 'd', 'e'],
meta_features=['meta1'])
imputed = featurize.impute_featureset(fset)
npt.assert_allclose(fset.amplitude.values, imputed.amplitude.values)
assert isinstance(imputed, pd.DataFrame)
fset.amplitude.values[0] = np.inf
fset.amplitude.values[1] = np.nan
amp_values = fset.amplitude.values[2:]
other_values = fset.values.T.ravel()[2:]
imputed = featurize.impute_featureset(fset, strategy='constant',
value=None)
npt.assert_allclose(-2 * np.nanmax(np.abs(other_values)),
imputed.amplitude.values[0:2])
imputed = featurize.impute_featureset(fset, strategy='constant',
value=-1e4)
npt.assert_allclose(-1e4, imputed.amplitude.values[0:2])
imputed = featurize.impute_featureset(fset, strategy='mean')
npt.assert_allclose(np.mean(amp_values), imputed.amplitude.values[0:2])
npt.assert_allclose(amp_values, imputed.amplitude.values[2:])
imputed = featurize.impute_featureset(fset, strategy='median')
npt.assert_allclose(np.median(amp_values), imputed.amplitude.values[0:2])
npt.assert_allclose(amp_values, imputed.amplitude.values[2:])
imputed = featurize.impute_featureset(fset, strategy='most_frequent')
npt.assert_allclose(scipy.stats.mode(amp_values).mode.item(),
imputed.amplitude.values[0:2])
npt.assert_allclose(amp_values, imputed.amplitude.values[2:])
featurize.impute_featureset(fset, strategy='constant', value=-1e4,
inplace=True)
npt.assert_allclose(-1e4, fset.amplitude.values[0:2])
with pytest.raises(NotImplementedError):
featurize.impute_featureset(fset, strategy='blah')
def test_roundtrip_featureset(tmpdir):
fset_path = os.path.join(str(tmpdir), 'test.npz')
for n_channels in [1, 3]:
for labels in [['class1', 'class2'], []]:
fset, labels = sample_featureset(3, n_channels, ['amplitude'],
labels, names=['a', 'b', 'c'],
meta_features=['meta1'])
pred_probs = pd.DataFrame(np.random.random((len(fset), 2)),
index=fset.index.values,
columns=['class1', 'class2'])
featurize.save_featureset(fset, fset_path, labels=labels,
pred_probs=pred_probs)
fset_loaded, data_loaded = featurize.load_featureset(fset_path)
npt.assert_allclose(fset.values, fset_loaded.values)
npt.assert_array_equal(fset.index, fset_loaded.index)
npt.assert_array_equal(fset.columns, fset_loaded.columns)
assert isinstance(fset_loaded, pd.DataFrame)
npt.assert_array_equal(labels, data_loaded['labels'])
npt.assert_allclose(pred_probs, data_loaded['pred_probs'])
npt.assert_array_equal(pred_probs.columns,
data_loaded['pred_probs'].columns)
def test_ignore_exceptions():
import cesium.features.graphs
def raise_exc(x):
raise ValueError()
old_value = cesium.features.graphs.dask_feature_graph['mean']
try:
cesium.features.graphs.dask_feature_graph['mean'] = (raise_exc, 't')
t, m, e = sample_values()
features_to_use = ['mean']
with pytest.raises(ValueError):
fset = featurize.featurize_time_series(t, m, e, features_to_use,
scheduler=dask.get,
raise_exceptions=True)
fset = featurize.featurize_time_series(t, m, e, features_to_use,
scheduler=dask.get,
raise_exceptions=False)
assert | np.isnan(fset.values) | numpy.isnan |
#!/usr/bin/python
import sys
import os
import json
# -*- coding:utf8 -*-
import numpy as np
import math
import Control_Exp1001 as CE
import torch.utils.data as Data
import matplotlib.pyplot as plt
import random
import sklearn.metrics.base
from sklearn.metrics import mean_squared_error
import torch.nn as nn
import torch.nn.functional as F
from Control_Exp1001.simulation.thickener import Thickener
from torch.autograd import Variable
import torch
import torch.optim as optim
from Control_Exp1001.control.base_ac import ACBase
from Control_Exp1001.demo.thickener.ILPL.critic import Critic
from Control_Exp1001.demo.thickener.ILPL.actor import Actor
from Control_Exp1001.demo.thickener.ILPL.predict import Model
sys.path.append(('./'))
import itertools
from Control_Exp1001.demo.flotation.plotuilt import PltUtil
import mpl_toolkits.mplot3d as p3d
from pylab import contourf
from pylab import contour
class HDP(ACBase):
def __init__(self,
gpu_id=1,
replay_buffer = None,
u_bounds = None,
exploration = None,
env=None,
predict_training_rounds=10000,
gamma=0.6,
batch_size = 1,
predict_batch_size=32,
model_nn_error_limit = 0.08,
critic_nn_error_limit = 1,
actor_nn_error_limit = 0.1,
actor_nn_lr = 0.01,
critic_nn_lr = 0.01,
model_nn_lr = 0.01,
indice_y = None,
indice_u = None,
indice_y_star = None,
indice_c=None,
hidden_model = 10,
hidden_critic = 14,
hidden_actor = 10,
predict_epoch = 35,
Nc = 500
):
"""
:param gpu_id:
:param replay_buffer:
:param u_bounds:
:param exploration:
:param env:
:param predict_training_rounds: 训练预测模型时使用的真实数据条数
:param Vm:
:param Lm:
:param Va:
:param La:
:param Lc:
:param Vc:
:param gamma:
:param batch_size:
:param predict_batch_size: 训练预测模型时的batch_size
:param model_nn_error_limit:
:param critic_nn_error_limit: critic网络的误差限
:param actor_nn_loss:
:param u_iter: 求解u*时的迭代次数
:param u_begin: 求解u*时，第一次迭代的其实u(k)
:param indice_y: y在state中的位置
:param indice_y_star: *在state中的位置
:param u_first: 第一次控制时的命令
"""
super(HDP, self).__init__(gpu_id=gpu_id,replay_buffer=replay_buffer,
u_bounds=u_bounds,exploration=exploration)
if env is None:
env = Thickener()
self.env=env
self.predict_training_rounds = predict_training_rounds
self.device = None
self.cuda_device(gpu_id)
self.batch_size = batch_size
self.predict_batch_size = predict_batch_size
self.predict_training_losses = []
self.model_nn = None
self.model_nn_error_limit = model_nn_error_limit
self.critic_nn_error_limit = critic_nn_error_limit
self.actor_nn_error_limit = actor_nn_error_limit
self.u_grad = [0, 0]
self.y_grad = [0, 0]
dim_c = env.size_yudc[3]
dim_y = env.size_yudc[0]
dim_u = env.size_yudc[1]
# Train model neural network
self.model_nn = nn.Sequential(
nn.Linear(dim_y+dim_u+dim_c, hidden_model),
nn.Tanh(),
nn.Linear(hidden_model, dim_y)
)
self.model_nn_optim = torch.optim.Adam(self.model_nn.parameters(), lr=model_nn_lr)
#self.train_identification_model()
#mse = self.test_predict_model(test_rounds=400)
#定义actor网络相关
self.actor_nn = nn.Sequential(
nn.Linear(2*dim_y+dim_c, hidden_actor, bias=False),
nn.Tanh(),
nn.Linear(hidden_actor, dim_u),
nn.Tanh(),
# nn.Linear(dim_u, dim_u)
)
self.actor_nn_optim = torch.optim.Adam(self.actor_nn.parameters(), lr=actor_nn_lr)
#定义critic网络相关:HDP
self.critic_nn = nn.Sequential(
nn.Linear(dim_y+dim_y+dim_c, hidden_critic, bias=False),
nn.Tanh(),
nn.Linear(hidden_critic, 1),
)
self.critic_nn_optim = torch.optim.Adam(self.critic_nn.parameters(), lr=critic_nn_lr)
self.critic_criterion = torch.nn.MSELoss()
self.gamma = gamma
if indice_y is None:
indice_y = [2,3]
if indice_y_star is None:
indice_y_star = [0,1]
if indice_u is None:
indice_u = [4,5]
self.indice_y = indice_y
self.indice_y_star = indice_y_star
self.indice_c = [6, 7]
self.indice_u = indice_u
self.predict_epoch = predict_epoch
self.Nc = Nc
def cuda_device(self, cuda_id):
use_cuda = torch.cuda.is_available()
cuda = 'cuda:'+str(cuda_id)
self.device = torch.device(cuda if use_cuda else "cpu")
def _act(self, state):
y = self.normalize_y(state[self.indice_y])
y_star = self.normalize_y(state[self.indice_y_star])
c = self.normalize_c(state[self.indice_c])
x = torch.FloatTensor(np.hstack((y, y_star,c))).unsqueeze(0)
act = self.actor_nn(x).detach().squeeze(0).numpy()
# make the output action locate in bounds of constraint
# U = (max - min)/2 * u + (max + min)/2
self.delta_u = self.env.u_bounds[:, 1] - self.env.u_bounds[:, 0]
self.mid_u = np.mean(self.env.u_bounds, axis=1)
A = np.matrix(np.diag(self.delta_u/2))
B = np.matrix(self.mid_u).T
act = A*np.matrix(act).T + B
act = np.array(act).reshape(-1)
# self.actor_nn[-1].weight.data = torch.FloatTensor()
# self.actor_nn[-1].bias.data = torch.FloatTensor(self.mid_u)
# self.actor_nn[-1].weight.requires_grad = False
# self.actor_nn[-1].bias.requires_grad = False
return act
def _train(self, s, u, ns, r, done):
# 先放回放池
self.replay_buffer.push(s, u, r, ns, done)
# if len(self.replay_buffer) < self.batch_size:
# return
# 从回放池取数据，默认1条
state, action, reward, next_state, done = self.replay_buffer.sample(
# 尽快开始训练，而不能等batchsize满了再开始
min(len(self.replay_buffer), self.batch_size)
)
# 更新模型
self.update_model(state, action, reward, next_state, done)
def update_model(self,state, action, penalty, next_state, done):
tmp_state = | np.copy(state) | numpy.copy |
import numpy as np
def rotate_point_cloud(batch_data):
""" Randomly rotate the point clouds to augument the dataset
rotation is per shape based along up direction
Input:
BxNx3 array, original batch of point clouds
Return:
BxNx3 array, rotated batch of point clouds
"""
rotated_data = np.zeros(batch_data.shape, dtype=np.float32)
for k in range(batch_data.shape[0]):
rotation_angle = np.random.uniform() * 2 * np.pi
cosval = np.cos(rotation_angle)
sinval = np.sin(rotation_angle)
rotation_matrix = np.array([[cosval, -sinval, 0],
[sinval, cosval, 0],
[0, 0, 1]])
shape_pc = batch_data[k, ...]
rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)
return rotated_data
def rotate_perturbation_point_cloud(batch_data, angle_sigma=0.06, angle_clip=0.18):
""" Randomly perturb the point clouds by small rotations
Input:
BxNx3 array, original batch of point clouds
Return:
BxNx3 array, rotated batch of point clouds
"""
rotated_data = np.zeros(batch_data.shape, dtype=np.float32)
for k in range(batch_data.shape[0]):
angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)
Rx = np.array([[1,0,0],
[0,np.cos(angles[0]),-np.sin(angles[0])],
[0,np.sin(angles[0]),np.cos(angles[0])]])
Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],
[0,1,0],
[-np.sin(angles[1]),0,np.cos(angles[1])]])
Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],
[np.sin(angles[2]),np.cos(angles[2]),0],
[0,0,1]])
R = np.dot(Rz, np.dot(Ry,Rx))
shape_pc = batch_data[k, ...]
rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), R)
return rotated_data
def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):
""" Randomly jitter points. jittering is per point.
Input:
BxNx3 array, original batch of point clouds
Return:
BxNx3 array, jittered batch of point clouds
"""
B, N, C = batch_data.shape
assert(clip > 0)
jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)
jittered_data += batch_data
return jittered_data
def random_drop_n_cuboids(batch_data):
""" Randomly drop N cuboids from the point cloud.
Input:
BxNx3 array, original batch of point clouds
Return:
BxNx3 array, dropped batch of point clouds
"""
batch_data = random_drop_point_cloud(batch_data)
cuboids_count = 1
while cuboids_count < 5 and np.random.uniform(0., 1.) > 0.3:
batch_data = random_drop_point_cloud(batch_data)
cuboids_count += 1
return batch_data
def check_aspect2D(crop_range, aspect_min):
xy_aspect = np.min(crop_range[:2])/ | np.max(crop_range[:2]) | numpy.max |
from util import *
import numpy as np
K = np.array( [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2], np.uint32)
STATE = | np.array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19], np.uint32) | 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])
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(160, 'R 3 m :H', transformations)
space_groups[160] = sg
space_groups['R 3 m :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,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))
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,7])
trans_den = N.array([3,3,6])
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,7])
trans_den = N.array([3,3,6])
transformations.append((rot, 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,7])
trans_den = N.array([3,3,6])
transformations.append((rot, 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,5])
trans_den = N.array([3,3,6])
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,5])
trans_den = N.array([3,3,6])
transformations.append((rot, 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,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(161, 'R 3 c :H', transformations)
space_groups[161] = sg
space_groups['R 3 c :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))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
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(162, 'P -3 1 m', transformations)
space_groups[162] = 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([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))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
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(163, 'P -3 1 c', transformations)
space_groups[163] = 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])
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,1,0,0,0,-1])
rot.shape = (3, 3)
trans_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(164, 'P -3 m 1', transformations)
space_groups[164] = 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([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))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
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(165, 'P -3 c 1', transformations)
space_groups[165] = 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([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([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([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))
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(166, 'R -3 m :H', transformations)
space_groups[166] = sg
space_groups['R -3 m :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,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))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
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))
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,7])
trans_den = N.array([3,3,6])
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,7])
trans_den = N.array([3,3,6])
transformations.append((rot, 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,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_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,1])
trans_den = N.array([3,3,6])
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,1])
trans_den = N.array([3,3,6])
transformations.append((rot, 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,1])
trans_den = N.array([3,3,6])
transformations.append((rot, 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,5])
trans_den = N.array([3,3,6])
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,5])
trans_den = N.array([3,3,6])
transformations.append((rot, 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,5])
trans_den = N.array([3,3,6])
transformations.append((rot, 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,6])
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,6])
transformations.append((rot, 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,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(167, 'R -3 c :H', transformations)
space_groups[167] = sg
space_groups['R -3 c :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([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,1,0,0,0,1])
rot.shape = (3, 3)
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))
sg = SpaceGroup(168, 'P 6', transformations)
space_groups[168] = sg
space_groups['P 6'] = 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,-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,6])
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,5])
trans_den = N.array([1,1,6])
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,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(169, 'P 61', transformations)
space_groups[169] = sg
space_groups['P 61'] = 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,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
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,6])
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,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(170, 'P 65', transformations)
space_groups[170] = sg
space_groups['P 65'] = 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,-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,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,-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,0,0,0,-1,0,0,0,1])
rot.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(171, 'P 62', transformations)
space_groups[171] = sg
space_groups['P 62'] = 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,-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,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,-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,0,0,0,-1,0,0,0,1])
rot.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(172, 'P 64', transformations)
space_groups[172] = sg
space_groups['P 64'] = 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,-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,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,-1,0,0,0,1])
rot.shape = (3, 3)
trans_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,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(173, 'P 63', transformations)
space_groups[173] = sg
space_groups['P 63'] = 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,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,-1,0,0,0,-1])
rot.shape = (3, 3)
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))
sg = SpaceGroup(174, 'P -6', transformations)
space_groups[174] = sg
space_groups['P -6'] = 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,-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,1,0,0,0,1])
rot.shape = (3, 3)
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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_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,-1,0,0,0,-1])
rot.shape = (3, 3)
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))
sg = SpaceGroup(175, 'P 6/m', transformations)
space_groups[175] = sg
space_groups['P 6/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,-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,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,-1,0,0,0,1])
rot.shape = (3, 3)
trans_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,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,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,-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,1,0,0,0,-1])
rot.shape = (3, 3)
trans_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,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(176, 'P 63/m', transformations)
space_groups[176] = sg
space_groups['P 63/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,-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,1,0,0,0,1])
rot.shape = (3, 3)
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([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
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,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(177, 'P 6 2 2', transformations)
space_groups[177] = sg
space_groups['P 6 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,-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,6])
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,5])
trans_den = N.array([1,1,6])
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,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,2])
trans_den = N.array([1,1,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([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,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,5])
trans_den = N.array([1,1,6])
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,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(178, 'P 61 2 2', transformations)
space_groups[178] = sg
space_groups['P 61 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,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
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,6])
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,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,1])
trans_den = N.array([1,1,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([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,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,1])
trans_den = N.array([1,1,6])
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,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(179, 'P 65 2 2', transformations)
space_groups[179] = sg
space_groups['P 65 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,-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,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,-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,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,1])
trans_den = N.array([1,1,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([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,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,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,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(180, 'P 62 2 2', transformations)
space_groups[180] = sg
space_groups['P 62 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,-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,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,-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,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,2])
trans_den = N.array([1,1,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([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,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,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,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(181, 'P 64 2 2', transformations)
space_groups[181] = sg
space_groups['P 64 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,-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,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,-1,0,0,0,1])
rot.shape = (3, 3)
trans_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([-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))
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(182, 'P 63 2 2', transformations)
space_groups[182] = sg
space_groups['P 63 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,-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,1,0,0,0,1])
rot.shape = (3, 3)
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([-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([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(183, 'P 6 m m', transformations)
space_groups[183] = sg
space_groups['P 6 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,-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,1,0,0,0,1])
rot.shape = (3, 3)
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([-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))
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(184, 'P 6 c c', transformations)
space_groups[184] = sg
space_groups['P 6 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([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,2])
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,2])
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,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))
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,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(185, 'P 63 c m', transformations)
space_groups[185] = sg
space_groups['P 63 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,-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,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,-1,0,0,0,1])
rot.shape = (3, 3)
trans_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,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,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([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(186, 'P 63 m c', transformations)
space_groups[186] = sg
space_groups['P 63 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([-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,-1,0,0,0,-1])
rot.shape = (3, 3)
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))
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([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
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(187, 'P -6 m 2', transformations)
space_groups[187] = sg
space_groups['P -6 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,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,-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,-1,0,0,0,1])
rot.shape = (3, 3)
trans_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))
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([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))
sg = SpaceGroup(188, 'P -6 c 2', transformations)
space_groups[188] = sg
space_groups['P -6 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,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,-1,0,0,0,-1])
rot.shape = (3, 3)
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([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(189, 'P -6 2 m', transformations)
space_groups[189] = sg
space_groups['P -6 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([-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,2])
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,2])
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([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,-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(190, 'P -6 2 c', transformations)
space_groups[190] = sg
space_groups['P -6 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([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,1,0,0,0,1])
rot.shape = (3, 3)
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([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
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,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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_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,-1,0,0,0,-1])
rot.shape = (3, 3)
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([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
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,-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(191, 'P 6/m m m', transformations)
space_groups[191] = sg
space_groups['P 6/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,-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,1,0,0,0,1])
rot.shape = (3, 3)
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([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
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,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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_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,-1,0,0,0,-1])
rot.shape = (3, 3)
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([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
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,-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(192, 'P 6/m c c', transformations)
space_groups[192] = sg
space_groups['P 6/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([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,2])
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,2])
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([-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,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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_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,-1])
trans_den = N.array([1,1,2])
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,2])
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([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,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(193, 'P 63/m c m', transformations)
space_groups[193] = sg
space_groups['P 63/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,-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,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,-1,0,0,0,1])
rot.shape = (3, 3)
trans_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([-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))
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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_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,-1])
trans_den = N.array([1,1,2])
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,2])
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([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))
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(194, 'P 63/m m c', transformations)
space_groups[194] = sg
space_groups['P 63/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,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
rot.shape = (3, 3)
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,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,1,-1,0,0])
rot.shape = (3, 3)
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,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.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(195, 'P 2 3', transformations)
space_groups[195] = sg
space_groups['P 2 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,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
rot.shape = (3, 3)
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,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,1,-1,0,0])
rot.shape = (3, 3)
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,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_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([0,0,1,1,0,0,0,1,0])
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,0,0,1,1,0,0])
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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([0,0,1,1,0,0,0,1,0])
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,0,0,1,1,0,0])
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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([0,0,1,1,0,0,0,1,0])
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,0,0,1,1,0,0])
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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(196, 'F 2 3', transformations)
space_groups[196] = sg
space_groups['F 2 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,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
rot.shape = (3, 3)
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,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,1,-1,0,0])
rot.shape = (3, 3)
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,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, 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,0,1,1,0,0,0,1,0])
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,0,0,1,1,0,0])
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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(197, 'I 2 3', transformations)
space_groups[197] = sg
space_groups['I 2 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,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(198, 'P 21 3', transformations)
space_groups[198] = sg
space_groups['P 21 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,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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,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([0,0,1,1,0,0,0,1,0])
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,0,0,1,1,0,0])
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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([0,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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([0,1,0,0,0,-1,-1,0,0])
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([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(199, 'I 21 3', transformations)
space_groups[199] = sg
space_groups['I 21 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,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
rot.shape = (3, 3)
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,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,1,-1,0,0])
rot.shape = (3, 3)
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,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
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,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,-1,-1,0,0])
rot.shape = (3, 3)
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,0,0,1,-1,0,0])
rot.shape = (3, 3)
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,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
rot.shape = (3, 3)
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,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.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(200, 'P m -3', transformations)
space_groups[200] = sg
space_groups['P m -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,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
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,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,-1,-1,0,0])
rot.shape = (3, 3)
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,0,0,1,-1,0,0])
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,0,-1,1,0,0,0,1,0])
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,0,0,-1,1,0,0])
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,0,1,1,0,0,0,-1,0])
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,0,1,-1,0,0,0,1,0])
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,0,0,1,1,0,0])
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))
sg = SpaceGroup(201, 'P n -3 :2', transformations)
space_groups[201] = sg
space_groups['P n -3 :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,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
rot.shape = (3, 3)
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,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,1,-1,0,0])
rot.shape = (3, 3)
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,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
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,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,-1,-1,0,0])
rot.shape = (3, 3)
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,0,0,1,-1,0,0])
rot.shape = (3, 3)
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,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
rot.shape = (3, 3)
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,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_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([0,0,1,1,0,0,0,1,0])
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,0,0,1,1,0,0])
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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([0,0,-1,-1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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,0,0,1,-1,0,0])
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,0,-1,1,0,0,0,1,0])
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,0,0,-1,1,0,0])
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,0,1,1,0,0,0,-1,0])
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,0,1,-1,0,0,0,1,0])
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,0,0,1,1,0,0])
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([0,0,1,1,0,0,0,1,0])
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,0,0,1,1,0,0])
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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([0,0,-1,-1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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,0,0,1,-1,0,0])
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,0,-1,1,0,0,0,1,0])
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,0,0,-1,1,0,0])
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,0,1,1,0,0,0,-1,0])
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,0,1,-1,0,0,0,1,0])
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,0,0,1,1,0,0])
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([0,0,1,1,0,0,0,1,0])
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,0,0,1,1,0,0])
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,0,0,-1,1,0,0])
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,0,1,-1,0,0,0,-1,0])
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,0,0,1,-1,0,0])
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,0,-1,-1,0,0,0,1,0])
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,0,-1,1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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([0,0,-1,-1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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,0,0,1,-1,0,0])
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,0,-1,1,0,0,0,1,0])
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,0,0,-1,1,0,0])
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,0,1,1,0,0,0,-1,0])
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,0,1,-1,0,0,0,1,0])
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,0,0,1,1,0,0])
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(202, 'F m -3', transformations)
space_groups[202] = sg
space_groups['F m -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,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
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,0,0,1,1,0,0])
rot.shape = (3, 3)
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,0,0,-1,1,0,0])
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([0,0,1,-1,0,0,0,-1,0])
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([0,-1,0,0,0,1,-1,0,0])
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([0,0,-1,-1,0,0,0,1,0])
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([0,0,-1,1,0,0,0,-1,0])
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([0,1,0,0,0,-1,-1,0,0])
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([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([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
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,0,0,-1,-1,0,0])
rot.shape = (3, 3)
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,0,0,1,-1,0,0])
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([0,0,-1,1,0,0,0,1,0])
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([0,1,0,0,0,-1,1,0,0])
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([0,0,1,1,0,0,0,-1,0])
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([0,0,1,-1,0,0,0,1,0])
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([0,-1,0,0,0,1,1,0,0])
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([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([0,0,1,1,0,0,0,1,0])
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,0,0,1,1,0,0])
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,0,0,-1,1,0,0])
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([0,0,1,-1,0,0,0,-1,0])
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([0,-1,0,0,0,1,-1,0,0])
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([0,0,-1,-1,0,0,0,1,0])
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([0,0,-1,1,0,0,0,-1,0])
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([0,1,0,0,0,-1,-1,0,0])
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([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([0,0,-1,-1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
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,0,0,1,-1,0,0])
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([0,0,-1,1,0,0,0,1,0])
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([0,1,0,0,0,-1,1,0,0])
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([0,0,1,1,0,0,0,-1,0])
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([0,0,1,-1,0,0,0,1,0])
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([0,-1,0,0,0,1,1,0,0])
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([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([0,0,1,1,0,0,0,1,0])
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,0,0,1,1,0,0])
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,0,0,-1,1,0,0])
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([0,0,1,-1,0,0,0,-1,0])
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([0,-1,0,0,0,1,-1,0,0])
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([0,0,-1,-1,0,0,0,1,0])
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([0,0,-1,1,0,0,0,-1,0])
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([0,1,0,0,0,-1,-1,0,0])
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([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([0,0,-1,-1,0,0,0,-1,0])
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,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = | N.array([2,1,2]) | numpy.array |
#!/usr/bin/env python
"""Very simple SVG rasterizer
NOT SUPPORTED:
- markers
- symbol
- color-interpolation and filter-color-interpolation attributes
PARTIALLY SUPPORTED:
- text (textPath is not supported)
- fonts
- font resolution logic is very basic
- style font attribute is not parsed only font-* attrs are supported
KNOWN PROBLEMS:
- multiple pathes over going over the same pixels are breakin antialising
(would draw all pixels with multiplied AA coverage (clamped)).
"""
from __future__ import annotations
import builtins
import gzip
import io
import math
import numpy as np
import numpy.typing as npt
import os
import re
import struct
import sys
import textwrap
import time
import warnings
import xml.etree.ElementTree as etree
import zlib
from functools import reduce, partial
from typing import Any, Callable, NamedTuple, List, Tuple, Optional, Dict
EPSILON = sys.float_info.epsilon
FLOAT_RE = re.compile(r"[-+]?(?:(?:\d*\.\d+)|(?:\d+\.?))(?:[Ee][+-]?\d+)?")
FLOAT = np.float64
# ------------------------------------------------------------------------------
# Layer
# ------------------------------------------------------------------------------
COMPOSE_OVER = 0
COMPOSE_OUT = 1
COMPOSE_IN = 2
COMPOSE_ATOP = 3
COMPOSE_XOR = 4
COMPOSE_PRE_ALPHA = {COMPOSE_OVER, COMPOSE_OUT, COMPOSE_IN, COMPOSE_ATOP, COMPOSE_XOR}
BBox = Tuple[float, float, float, float]
FNDArray = npt.NDArray[FLOAT]
class Layer(NamedTuple):
image: np.ndarray[Tuple[int, int, int], FLOAT]
offset: Tuple[int, int]
pre_alpha: bool
linear_rgb: bool
@property
def x(self) -> int:
return self.offset[0]
@property
def y(self) -> int:
return self.offset[1]
@property
def width(self) -> int:
return self.image.shape[1]
@property
def height(self) -> int:
return self.image.shape[0]
@property
def channels(self) -> int:
return self.image.shape[2]
@property
def bbox(self) -> BBox:
return (*self.offset, *self.image.shape[:2])
def translate(self, x: int, y: int) -> Layer:
offset = (self.x + x, self.y + y)
return Layer(self.image, offset, self.pre_alpha, self.linear_rgb)
def color_matrix(self, matrix: np.ndarray) -> Layer:
"""Apply color matrix transformation"""
if not isinstance(matrix, np.ndarray) or matrix.shape != (4, 5):
raise ValueError("expected 4x5 matrix")
layer = self.convert(pre_alpha=False, linear_rgb=True)
M = matrix[:, :4]
B = matrix[:, 4]
image = np.matmul(layer.image, M.T) + B
np.clip(image, 0, 1, out=image)
return Layer(image, layer.offset, pre_alpha=False, linear_rgb=True)
def convolve(self, kernel: np.ndarray) -> Layer:
"""Convlve layer"""
try:
from scipy.signal import convolve
layer = self.convert(pre_alpha=False, linear_rgb=True)
kw, kh = kernel.shape
image = convolve(layer.image, kernel[..., None])
x, y = int(layer.x - kw / 2), int(layer.y - kh / 2)
return Layer(image, (x, y), pre_alpha=False, linear_rgb=True)
except ImportError:
warnings.warn("Layer::convolve requires `scipy`")
return self
def morphology(self, x: int, y: int, method: str) -> Layer:
"""Morphology filter operation
Morphology is essentially {min|max} pooling with [1, 1] stride
"""
layer = self.convert(pre_alpha=True, linear_rgb=True)
image = pooling(layer.image, ksize=(x, y), stride=(1, 1), method=method)
return Layer(image, layer.offset, pre_alpha=True, linear_rgb=True)
def convert(self, pre_alpha=None, linear_rgb=None) -> Layer:
"""Convert image if needed to specified alpha and colorspace"""
pre_alpha = self.pre_alpha if pre_alpha is None else pre_alpha
linear_rgb = self.linear_rgb if linear_rgb is None else linear_rgb
if self.channels == 1:
# single channel value assumed to be alpha
return Layer(self.image, self.offset, pre_alpha, linear_rgb)
in_image, out_offset, out_pre_alpha, out_linear_rgb = self
out_image = None
if out_linear_rgb != linear_rgb:
out_image = in_image.copy()
# convert to straight alpha first if needed
if out_pre_alpha:
out_image = color_pre_to_straight_alpha(out_image)
out_pre_alpha = False
if linear_rgb:
out_image = color_srgb_to_linear(out_image)
else:
out_image = color_linear_to_srgb(out_image)
out_linear_rgb = linear_rgb
if out_pre_alpha != pre_alpha:
if out_image is None:
out_image = in_image.copy()
if pre_alpha:
out_image = color_straight_to_pre_alpha(out_image)
else:
out_image = color_pre_to_straight_alpha(out_image)
out_pre_alpha = pre_alpha
if out_image is None:
return self
return Layer(out_image, out_offset, out_pre_alpha, out_linear_rgb)
def background(self, color: np.ndarray) -> Layer:
layer = self.convert(pre_alpha=True, linear_rgb=True)
image = canvas_compose(COMPOSE_OVER, color[None, None, ...], layer.image)
return Layer(image, layer.offset, pre_alpha=True, linear_rgb=True)
def opacity(self, opacity: float, linear_rgb=False) -> Layer:
"""Apply additinal opacity"""
layer = self.convert(pre_alpha=True, linear_rgb=linear_rgb)
image = layer.image * opacity
return Layer(image, layer.offset, pre_alpha=True, linear_rgb=linear_rgb)
@staticmethod
def compose(layers: List[Layer], method=COMPOSE_OVER, linear_rgb=False) -> Optional[Layer]:
"""Compose multiple layers into one with specified `method`
Composition in linear RGB is correct one but SVG composes in sRGB
by default. Only filter is composing in linear RGB by default.
"""
if not layers:
return None
elif len(layers) == 1:
return layers[0]
images = []
pre_alpha = method in COMPOSE_PRE_ALPHA
for layer in layers:
layer = layer.convert(pre_alpha=pre_alpha, linear_rgb=linear_rgb)
images.append((layer.image, layer.offset))
#print([i[0].shape for i in images])
blend = partial(canvas_compose, method)
if method == COMPOSE_IN:
result = canvas_merge_intersect(images, blend)
elif method == COMPOSE_OVER:
start = time.time()
result = canvas_merge_union(images, full=False, blend=blend)
print("render from image,offset pair take:",time.time()-start)
else:
result = canvas_merge_union(images, full=True, blend=blend)
if result is None:
return None
image, offset = result
return Layer(image, offset, pre_alpha=pre_alpha, linear_rgb=linear_rgb)
def write_png(self, output=None):
if self.channels != 4:
raise ValueError("Only RGBA layers are supported")
layer = self.convert(pre_alpha=False, linear_rgb=False)
return canvas_to_png(layer.image, output)
def __repr__(self):
return "Layer(x={}, y={}, w={}, h={}, pre_alpha={}, linear_rgb={})".format(
self.x, self.y, self.width, self.height, self.pre_alpha, self.linear_rgb
)
def show(self, format=None):
"""Show layer on terminal if `imshow` if available
NOTE: used only for debugging
"""
try:
from imshow import show
layer = self.convert(pre_alpha=False, linear_rgb=False)
show(layer.image, format=format)
except ImportError:
warnings.warn("to be able to show layer on terminal imshow is required")
def canvas_create(width, height, bg=None):
"""Create canvas of a specified size
Returns (canvas, transform) tuple:
canvas - float64 ndarray of (height, width, 4) shape
transform - transform from (x, y) to canvas pixel coordinates
"""
if bg is None:
canvas = np.zeros((height, width, 4), dtype=FLOAT)
else:
canvas = np.broadcast_to(bg, (height, width, 4)).copy()
return canvas, Transform().matrix(0, 1, 0, 1, 0, 0)
def canvas_to_png(canvas, output=None):
"""Convert (height, width, rgba{float64}) to PNG"""
def png_pack(output, tag, data):
checksum = 0xFFFFFFFF & zlib.crc32(data, zlib.crc32(tag))
output.write(struct.pack("!I", len(data)))
output.write(tag)
output.write(data)
output.write(struct.pack("!I", checksum))
height, width, _ = canvas.shape
data = io.BytesIO()
comp = zlib.compressobj(level=9)
for row in np.round(canvas * 255.0).astype(np.uint8):
data.write(comp.compress(b"\x00"))
data.write(comp.compress(row.tobytes()))
data.write(comp.flush())
output = io.BytesIO() if output is None else output
output.write(b"\x89PNG\r\n\x1a\n")
png_pack(output, b"IHDR", struct.pack("!2I5B", width, height, 8, 6, 0, 0, 0)),
png_pack(output, b"IDAT", data.getvalue()),
png_pack(output, b"IEND", b"")
return output
def canvas_compose(mode, dst, src):
"""Compose two alpha premultiplied images
https://ciechanow.ski/alpha-compositing/
http://ssp.impulsetrain.com/porterduff.html
"""
src_a = src[..., -1:] if len(src.shape) == 3 else src
dst_a = dst[..., -1:] if len(dst.shape) == 3 else dst
if mode == COMPOSE_OVER:
return src + dst * (1 - src_a)
elif mode == COMPOSE_OUT:
return src * (1 - dst_a)
elif mode == COMPOSE_IN:
return src * dst_a
elif mode == COMPOSE_ATOP:
return src * dst_a + dst * (1 - src_a)
elif mode == COMPOSE_XOR:
return src * (1 - dst_a) + dst * (1 - src_a)
elif isinstance(mode, tuple) and len(mode) == 4:
k1, k2, k3, k4 = mode
return (k1 * src * dst + k2 * src + k3 * dst + k4).clip(0, 1)
raise ValueError(f"invalid compose mode: {mode}")
canvas_compose_over = partial(canvas_compose, COMPOSE_OVER)
def canvas_merge_at(base, overlay, offset, blend=canvas_compose_over):
"""Alpha blend `overlay` on top of `base` at offset coordintate
Updates `base` with `overlay` in place.
"""
x, y = offset
b_h, b_w = base.shape[:2]
o_h, o_w = overlay.shape[:2]
clip = lambda v, l, h: l if v < l else h if v > h else v
b_x_low, b_x_high = clip(x, 0, b_h), clip(x + o_h, 0, b_h)
b_y_low, b_y_high = clip(y, 0, b_w), clip(y + o_w, 0, b_w)
effected = base[b_x_low:b_x_high, b_y_low:b_y_high]
if effected.size == 0:
return
o_x_low, o_x_high = clip(-x, 0, o_h), clip(b_h - x, 0, o_h)
o_y_low, o_y_high = clip(-y, 0, o_w), clip(b_w - y, 0, o_w)
overlay = overlay[o_x_low:o_x_high, o_y_low:o_y_high]
if overlay.size == 0:
return
effected[...] = blend(effected, overlay).clip(0, 1)
return base
def canvas_merge_union(layers, full=True, blend=canvas_compose_over):
"""Blend multiple `layers` into single large enough image"""
if not layers:
raise ValueError("can not blend zero layers")
elif len(layers) == 1:
return layers[0]
min_x, min_y, max_x, max_y = None, None, None, None
for image, offset in layers:
x, y = offset
w, h = image.shape[:2]
if min_x is None:
min_x, min_y = x, y
max_x, max_y = x + w, y + h
else:
min_x, min_y = min(min_x, x), min(min_y, y)
max_x, max_y = max(max_x, x + w), max(max_y, y + h)
width, height = max_x - min_x, max_y - min_y
if full:
output = None
for image, offset in layers:
x, y = offset
w, h = image.shape[:2]
ox, oy = x - min_x, y - min_y
image_full = np.zeros((width, height, 4), dtype=FLOAT)
image_full[ox : ox + w, oy : oy + h] = image
if output is None:
output = image_full
else:
output = blend(output, image_full)
else:
# this is optimization for method `over` blending
output = np.zeros((max_x - min_x, max_y - min_y, 4), dtype=FLOAT)
for index, (image, offset) in enumerate(layers):
x, y = offset
w, h = image.shape[:2]
ox, oy = x - min_x, y - min_y
effected = output[ox : ox + w, oy : oy + h]
if index == 0:
effected[...] = image
else:
effected[...] = blend(effected, image)
return output, (min_x, min_y)
def canvas_merge_intersect(layers, blend=canvas_compose_over):
"""Blend multiple `layers` into single image coverd by all layers"""
if not layers:
raise ValueError("can not blend zero layers")
elif len(layers) == 1:
return layers[0]
min_x, min_y, max_x, max_y = None, None, None, None
for layer, offset in layers:
x, y = offset
w, h = layer.shape[:2]
if min_x is None:
min_x, min_y = x, y
max_x, max_y = x + w, y + h
else:
min_x, min_y = max(min_x, x), max(min_y, y)
max_x, max_y = min(max_x, x + w), min(max_y, y + h)
if min_x >= max_x or min_y >= max_y:
return None # empty intersection
(first, (fx, fy)), *rest = layers
output = first[min_x - fx : max_x - fx, min_y - fy : max_y - fy]
w, h, c = output.shape
if c == 1:
output = np.broadcast_to(output, (w, h, 4))
output = output.copy()
for layer, offset in rest:
x, y = offset
output[...] = blend(output, layer[min_x - x : max_x - x, min_y - y : max_y - y])
return output, (min_x, min_y)
def pooling(mat, ksize, stride=None, method="max", pad=False):
"""Overlapping pooling on 2D or 3D data.
<mat>: ndarray, input array to pool.
<ksize>: tuple of 2, kernel size in (ky, kx).
<stride>: tuple of 2 or None, stride of pooling window.
If None, same as <ksize> (non-overlapping pooling).
<method>: str, 'max for max-pooling,
'mean' for mean-pooling.
<pad>: bool, pad <mat> or not. If no pad, output has size
(n-f)//s+1, n being <mat> size, f being kernel size, s stride.
if pad, output has size ceil(n/s).
Return <result>: pooled matrix.
"""
m, n = mat.shape[:2]
ky, kx = ksize
if stride is None:
stride = (ky, kx)
sy, sx = stride
if pad:
nx = int(np.ceil(n / float(sx)))
ny = int(np.ceil(m / float(sy)))
size = ((ny - 1) * sy + ky, (nx - 1) * sx + kx) + mat.shape[2:]
mat_pad = np.full(size, np.nan)
mat_pad[:m, :n, ...] = mat
else:
mat_pad = mat[: (m - ky) // sy * sy + ky, : (n - kx) // sx * sx + kx, ...]
# Get a strided sub-matrices view of an ndarray.
s0, s1 = mat_pad.strides[:2]
m1, n1 = mat_pad.shape[:2]
m2, n2 = ksize
view_shape = (1 + (m1 - m2) // stride[0], 1 + (n1 - n2) // stride[1], m2, n2) + mat_pad.shape[
2:
]
strides = (stride[0] * s0, stride[1] * s1, s0, s1) + mat_pad.strides[2:]
view = np.lib.stride_tricks.as_strided(mat_pad, view_shape, strides=strides)
if method == "max":
result = np.nanmax(view, axis=(2, 3))
elif method == "min":
result = np.nanmin(view, axis=(2, 3))
elif method == "mean":
result = np.nanmean(view, axis=(2, 3))
else:
raise ValueError(f"invalid poll method: {method}")
return result
def color_pre_to_straight_alpha(rgba):
"""Convert from premultiplied alpha inplace"""
rgb = rgba[..., :-1]
alpha = rgba[..., -1:]
np.divide(rgb, alpha, out=rgb, where=alpha > 0.0001)
np.clip(rgba, 0, 1, out=rgba)
return rgba
def color_straight_to_pre_alpha(rgba):
"""Convert to premultiplied alpha inplace"""
rgba[..., :-1] *= rgba[..., -1:]
return rgba
def color_linear_to_srgb(rgba):
"""Convert pixels from linear RGB to sRGB inplace"""
rgb = rgba[..., :-1]
small = rgb <= 0.0031308
rgb[small] = rgb[small] * 12.92
large = ~small
rgb[large] = 1.055 * np.power(rgb[large], 1.0 / 2.4) - 0.055
return rgba
def color_srgb_to_linear(rgba):
"""Convert pixels from sRGB to linear RGB inplace"""
rgb = rgba[..., :-1]
small = rgb <= 0.04045
rgb[small] = rgb[small] / 12.92
large = ~small
rgb[large] = np.power((rgb[large] + 0.055) / 1.055, 2.4)
return rgba
# ------------------------------------------------------------------------------
# Transform
# ------------------------------------------------------------------------------
class Transform:
__slots__: List[str] = ["m", "_m_inv"]
m: np.ndarray[Tuple[int, int], FLOAT]
_m_inv: np.ndarray[Tuple[int, int], FLOAT]
def __init__(self, matrix=None, matrix_inv=None):
if matrix is None:
self.m = np.identity(3)
self._m_inv = self.m
else:
self.m = matrix
self._m_inv = matrix_inv
def __matmul__(self, other: Transform) -> Transform:
return Transform(self.m @ other.m)
@property
def invert(self) -> Transform:
if self._m_inv is None:
self._m_inv = np.linalg.inv(self.m)
return Transform(self._m_inv, self.m)
def __call__(self, points: FNDArray) -> FNDArray:
if len(points) == 0:
return points
return points @ self.m[:2, :2].T + self.m[:2, 2]
def apply(self) -> Callable[[FNDArray], FNDArray]:
M = self.m[:2, :2].T
B = self.m[:2, 2]
return lambda points: points @ M + B
def matrix(self, m00, m01, m02, m10, m11, m12):
return Transform(self.m @ np.array([[m00, m01, m02], [m10, m11, m12], [0, 0, 1]]))
def translate(self, tx: float, ty: float) -> Transform:
return Transform(self.m @ np.array([[1, 0, tx], [0, 1, ty], [0, 0, 1]]))
def scale(self, sx, sy=None):
sy = sx if sy is None else sy
return Transform(self.m @ np.array([[sx, 0, 0], [0, sy, 0], [0, 0, 1]]))
def rotate(self, angle):
cos_a = math.cos(angle)
sin_a = math.sin(angle)
return Transform(self.m @ np.array([[cos_a, -sin_a, 0], [sin_a, cos_a, 0], [0, 0, 1]]))
def skew(self, ax, ay):
return Transform(
np.matmul(self.m, np.array([[1, math.tan(ax), 0], [math.tan(ay), 1, 0], [0, 0, 1]]))
)
def __repr__(self):
return str(np.around(self.m, 4).tolist()[:2])
def no_translate(self):
m = self.m.copy()
m[0, 2] = 0
m[1, 2] = 0
return Transform(m)
# ------------------------------------------------------------------------------
# Render scene
# ------------------------------------------------------------------------------
RENDER_FILL = 0
RENDER_STROKE = 1
RENDER_GROUP = 2
RENDER_OPACITY = 3
RENDER_CLIP = 4
RENDER_TRANSFORM = 5
RENDER_FILTER = 6
RENDER_MASK = 7
class Scene(tuple):
__slots__: List[str] = []
def __new__(cls, type, args):
return tuple.__new__(cls, (type, args))
@classmethod
def fill(cls, path, paint, fill_rule=None):
return cls(RENDER_FILL, (path, paint, fill_rule))
@classmethod
def stroke(cls, path, paint, width, linecap=None, linejoin=None):
return cls(RENDER_STROKE, (path, paint, width, linecap, linejoin))
@classmethod
def group(cls, children):
if not children:
raise ValueError("group have to contain at least one child")
if len(children) == 1:
return children[0]
return cls(RENDER_GROUP, children)
def opacity(self, opacity):
if opacity > 0.999:
return self
return Scene(RENDER_OPACITY, (self, opacity))
def clip(self, clip, bbox_units=False):
return Scene(RENDER_CLIP, (self, clip, bbox_units))
def mask(self, mask, bbox_units=False):
return Scene(RENDER_MASK, (self, mask, bbox_units))
def transform(self, transform):
type, args = self
if type == RENDER_TRANSFORM:
target, target_transform = args
return Scene(RENDER_TRANSFORM, (target, transform @ target_transform))
else:
return Scene(RENDER_TRANSFORM, (self, transform))
def filter(self, filter):
return Scene(RENDER_FILTER, (self, filter))
def render(self, transform, mask_only=False, viewport=None, linear_rgb=False):
"""Render graph"""
type, args = self
if type == RENDER_FILL:
path, paint, fill_rule = args
if mask_only:
return path.mask(transform, fill_rule=fill_rule, viewport=viewport)
else:
return path.fill(
transform, paint, fill_rule=fill_rule, viewport=viewport, linear_rgb=linear_rgb
)
elif type == RENDER_STROKE:
path, paint, width, linecap, linejoin = args
stroke = path.stroke(width, linecap, linejoin)
if mask_only:
return stroke.mask(transform, viewport=viewport)
else:
return stroke.fill(transform, paint, viewport=viewport, linear_rgb=linear_rgb)
elif type == RENDER_GROUP:
layers, hulls = [], []
start = time.time()
for child in args:
layer = child.render(transform, mask_only, viewport, linear_rgb)
if layer is None:
continue
layer, hull = layer
layers.append(layer)
hulls.append(hull)
group = Layer.compose(layers, COMPOSE_OVER, linear_rgb)
if not group:
return None
return group, ConvexHull.merge(hulls)
elif type == RENDER_OPACITY:
target, opacity = args
layer = target.render(transform, mask_only, viewport, linear_rgb)
if layer is None:
return None
layer, hull = layer
return layer.opacity(opacity, linear_rgb), hull
elif type == RENDER_CLIP:
target, clip, bbox_units = args
image_result = target.render(transform, mask_only, viewport, linear_rgb)
if image_result is None:
return None
image, hull = image_result
if bbox_units:
transform = hull.bbox_transform(transform)
clip_result = clip.render(transform, True, viewport, linear_rgb)
if clip_result is None:
return None
mask, _ = clip_result
result = Layer.compose([mask, image], COMPOSE_IN, linear_rgb)
if result is None:
return None
return result, hull
elif type == RENDER_TRANSFORM:
target, target_transfrom = args
return target.render(transform @ target_transfrom, mask_only, viewport, linear_rgb)
elif type == RENDER_MASK:
target, mask_scene, bbox_units = args
image_result = target.render(transform, mask_only, viewport, linear_rgb)
if image_result is None:
return None
image, hull = image_result
if bbox_units:
transform = hull.bbox_transform(transform)
mask_result = mask_scene.render(transform, mask_only, viewport, linear_rgb)
if mask_result is None:
return None
mask, _ = mask_result
mask = mask.convert(pre_alpha=False, linear_rgb=linear_rgb)
mask_image = mask.image[..., :3] @ [0.2125, 0.7154, 0.072] * mask.image[..., 3]
mask = Layer(mask_image[..., None], mask.offset, pre_alpha=False, linear_rgb=linear_rgb)
result = Layer.compose([mask, image], COMPOSE_IN, linear_rgb)
if result is None:
return None
return result, hull
elif type == RENDER_FILTER:
target, filter = args
image_result = target.render(transform, mask_only, viewport, linear_rgb)
if image_result is None:
return None
image, hull = image_result
return filter(transform, image), hull
else:
raise ValueError(f"unhandled scene type: {type}")
def to_path(self, transform: Transform):
"""Try to convert whole scene to a path (used only for testing)"""
def to_path(scene, transform):
type, args = scene
if type == RENDER_FILL:
path, _paint, _fill_rule = args
yield path.transform(transform)
elif type == RENDER_STROKE:
path, paint, width, linecap, linejoin = args
yield path.transform(transform).stroke(width, linecap, linejoin)
elif type == RENDER_GROUP:
for child in args:
yield from to_path(child, transform)
elif type == RENDER_OPACITY:
target, _opacity = args
yield from to_path(target, transform)
elif type == RENDER_CLIP:
target, _clip, _bbox_units = args
yield from to_path(target, transform)
elif type == RENDER_TRANSFORM:
target, target_transfrom = args
yield from to_path(target, transform @ target_transfrom)
elif type == RENDER_MASK:
target, _mask_scene, _bbox_units = args
yield from to_path(target, transform)
elif type == RENDER_FILTER:
target, _filter = args
yield from to_path(target, transform)
else:
raise ValueError(f"unhandled scene type: {type}")
subpaths = [spath for path in to_path(self, transform) for spath in path.subpaths]
return Path(subpaths)
def __repr__(self) -> str:
def repr_rec(scene, output, depth):
output.write(indent * depth)
type, args = scene
if type == RENDER_FILL:
path, paint, fill_rule = args
if isinstance(paint, np.ndarray):
paint = format_color(paint)
output.write(f"FILL fill_rule:{fill_rule} paint:{paint}\n")
output.write(textwrap.indent(repr(path), indent * (depth + 1)))
output.write("\n")
elif type == RENDER_STROKE:
path, paint, width, linecap, linejoin = args
if isinstance(paint, np.ndarray):
paint = format_color(paint)
output.write(f"STROKE ")
output.write(f"width:{width} ")
output.write(f"linecap:{linecap} ")
output.write(f"linejoin:{linejoin} ")
output.write(f"paint:{paint}\n")
output.write(textwrap.indent(repr(path), indent * (depth + 1)))
output.write("\n")
elif type == RENDER_GROUP:
output.write("GROUP\n")
for child in args:
repr_rec(child, output, depth + 1)
elif type == RENDER_OPACITY:
target, opacity = args
output.write(f"OPACITY {opacity}\n")
repr_rec(target, output, depth + 1)
elif type == RENDER_CLIP:
target, clip, bbox_units = args
output.write(f"CLIP bbox_units:{bbox_units}\n")
output.write(indent * (depth + 1))
output.write("CLIP_PATH\n")
repr_rec(clip, output, depth + 2)
output.write(indent * (depth + 1))
output.write("CLIP_TARGET\n")
repr_rec(target, output, depth + 2)
elif type == RENDER_MASK:
target, mask, bbox_units = args
output.write(f"MASK bbox_units:{bbox_units}\n")
output.write(indent * (depth + 1))
output.write("MAKS_PATH\n")
repr_rec(mask, output, depth + 2)
output.write(indent * (depth + 1))
output.write("MASK_TARGET\n")
repr_rec(target, output, depth + 2)
elif type == RENDER_TRANSFORM:
target, transform = args
output.write(f"TRANSFORM {transform}\n")
repr_rec(target, output, depth + 1)
elif type == RENDER_FILTER:
target, filter = args
output.write(f"FILTER {filter}\n")
repr_rec(target, output, depth + 1)
else:
raise ValueError(f"unhandled scene type: {type}")
return output
def format_color(cs):
return "#" + "".join(f"{c:0<2x}" for c in (cs * 255).astype(np.uint8))
indent = " "
return repr_rec(self, io.StringIO(), 0).getvalue()[:-1]
# ------------------------------------------------------------------------------
# Path
# ------------------------------------------------------------------------------
PATH_LINE = 0
PATH_QUAD = 1
PATH_CUBIC = 2
PATH_ARC = 3
PATH_CLOSED = 4
PATH_UNCLOSED = 5
PATH_LINES = {PATH_LINE, PATH_CLOSED, PATH_UNCLOSED}
PATH_FILL_NONZERO = "nonzero"
PATH_FILL_EVENODD = "evenodd"
STROKE_JOIN_MITER = "miter"
STROKE_JOIN_ROUND = "round"
STROKE_JOIN_BEVEL = "bevel"
STROKE_CAP_BUTT = "butt"
STROKE_CAP_ROUND = "round"
STROKE_CAP_SQUARE = "square"
class Path:
"""Single rendering unit that can be filled or converted to stroke path
`subpaths` is a list of tuples:
- `(PATH_LINE, (p0, p1))` - line from p0 to p1
- `(PATH_CUBIC, (p0, c0, c1, p1))` - cubic bezier curve from p0 to p1 with control c0, c1
- `(PATH_QUAD, (p0, c0, p1))` - quadratic bezier curve from p0 to p1 with control c0
- `(PATH_ARC, (center, rx, ry, phi, eta, eta_delta)` - arc with a center and to radii rx, ry
rotated to phi angle, going from inital eta to eta + eta_delta angle.
- `(PATH_CLOSED | PATH_UNCLOSED, (p0, p1))` - last segment of subpath `"closed"` if
path was closed and `"unclosed"` if path was not closed. p0 - end subpath
p1 - beggining of this subpath.
"""
__slots__ = ["subpaths"]
subpaths: List[List[Tuple[int, Tuple[Any, ...]]]]
def __init__(self, subpaths):
self.subpaths = subpaths
def __iter__(self):
"""Itearte over subpaths"""
return iter(self.subpaths)
def __bool__(self) -> bool:
return bool(self.subpaths)
def mask(
self,
transform: Transform,
fill_rule: Optional[str] = None,
viewport: Optional[BBox] = None,
):
"""Render path as a mask (alpha channel only image)"""
# convert all curves to cubic curves and lines
lines_defs, cubics_defs = [], []
for path in self.subpaths:
if not path:
continue
for cmd, args in path:
if cmd in PATH_LINES:
lines_defs.append(args)
elif cmd == PATH_CUBIC:
cubics_defs.append(args)
elif cmd == PATH_QUAD:
cubics_defs.append(bezier2_to_bezier3(args))
elif cmd == PATH_ARC:
cubics_defs.extend(arc_to_bezier3(*args))
else:
raise ValueError(f"unsupported path type: `{cmd}`")
#def __call__(self, points: FNDArray) -> FNDArray:
#if len(points) == 0:
#return points
#return points @ self.m[:2, :2].T + self.m[:2, 2]
# transform all curves into presentation coordinate system
lines = transform(np.array(lines_defs, dtype=FLOAT))
cubics = transform(np.array(cubics_defs, dtype=FLOAT))
# flattend (convet to lines) all curves
if cubics.size != 0:
# flatness of 0.1px gives good accuracy
if lines.size != 0:
lines = np.concatenate([lines, bezier3_flatten_batch(cubics, 0.1)])
else:
lines = bezier3_flatten_batch(cubics, 0.1)
if lines.size == 0:
return
# calculate size of the mask
min_x, min_y = np.floor(lines.reshape(-1, 2).min(axis=0)).astype(int) - 1
max_x, max_y = np.ceil(lines.reshape(-1, 2).max(axis=0)).astype(int) + 1
if viewport is not None:
vx, vy, vw, vh = viewport
min_x, min_y = max(vx, min_x), max(vy, min_y)
max_x, max_y = min(vx + vw, max_x), min(vy + vh, max_y)
width = max_x - min_x
height = max_y - min_y
if width <= 0 or height <= 0:
return
# create trace (signed coverage)
trace = np.zeros((width, height), dtype=FLOAT)
for points in lines - np.array([min_x, min_y]):
line_signed_coverage(trace, points)
# render mask
mask = np.cumsum(trace, axis=1)
if fill_rule is None or fill_rule == PATH_FILL_NONZERO:
mask = np.fabs(mask).clip(0, 1)
elif fill_rule == PATH_FILL_EVENODD:
mask = np.fabs(np.remainder(mask + 1.0, 2.0) - 1.0)
else:
raise ValueError(f"Invalid fill rule: {fill_rule}")
mask[mask < 1e-6] = 0 # reound down to zero very small mask values
output = Layer(mask[..., None], (min_x, min_y), pre_alpha=True, linear_rgb=True)
return output, ConvexHull(lines)
def fill(self, transform, paint, fill_rule=None, viewport=None, linear_rgb=True):
"""Render path by fill-ing it."""
if paint is None:
return None
# create a mask
mask = self.mask(transform, fill_rule, viewport)
if mask is None:
return None
mask, hull = mask
# create background with specified paint
if isinstance(paint, np.ndarray) and paint.shape == (4,):
if not linear_rgb:
paint = color_pre_to_straight_alpha(paint.copy())
paint = color_linear_to_srgb(paint)
paint = color_straight_to_pre_alpha(paint)
output = Layer(mask.image * paint, mask.offset, pre_alpha=True, linear_rgb=linear_rgb)
elif isinstance(paint, (GradLinear, GradRadial)):
if paint.bbox_units:
user_tr = hull.bbox_transform(transform).invert
else:
user_tr = transform.invert
# convert grad pixels to user coordinate system
pixels = user_tr(grad_pixels(mask.bbox))
if paint.linear_rgb is not None:
linear_rgb = paint.linear_rgb
image = paint.fill(pixels, linear_rgb=linear_rgb)
# NOTE: consider optimizing calculation of grad only for unmasked points
# masked = mask.image > EPSILON
# painted = paint.fill(
# pixels[np.broadcast_to(masked, pixels.shape)].reshape(-1, 2),
# linear_rgb=linear_rgb,
# )
# image = np.zeros((mask.width, mask.height, 4), dtype=FLOAT)
# image[np.broadcast_to(masked, image.shape)] = painted.reshape(-1)
background = Layer(image, mask.offset, pre_alpha=True, linear_rgb=linear_rgb)
# use `canvas_compose` directly to avoid needless allocation
background = background.convert(pre_alpha=True, linear_rgb=linear_rgb)
mask = mask.convert(pre_alpha=True, linear_rgb=linear_rgb)
image = canvas_compose(COMPOSE_IN, mask.image, background.image)
output = Layer(image, mask.offset, pre_alpha=True, linear_rgb=linear_rgb)
elif isinstance(paint, Pattern):
# render pattern
pat_tr = transform.no_translate()
if paint.scene_view_box:
if paint.bbox_units:
px, py, pw, ph = paint.bbox()
_hx, _hy, hw, hh = hull.bbox(transform)
bbox = (px * hw, py * hh, pw * hw, ph * hh)
else:
bbox = paint.bbox()
pat_tr @= svg_viewbox_transform(bbox, paint.scene_view_box)
elif paint.scene_bbox_units:
pat_tr = hull.bbox_transform(pat_tr)
pat_tr @= paint.transform
result = paint.scene.render(pat_tr, linear_rgb=linear_rgb)
if result is None:
return None
pat_layer, _pat_hull = result
# repeat pattern
repeat_tr = transform
if paint.bbox_units:
repeat_tr = hull.bbox_transform(repeat_tr)
repeat_tr @= paint.transform
repeat_tr = repeat_tr.no_translate()
offsets = repeat_tr.invert(grad_pixels(mask.bbox))
offsets = repeat_tr(
np.remainder(offsets - [paint.x, paint.y], [paint.width, paint.height])
)
offsets = offsets.astype(int)
corners = repeat_tr(
[
[0, 0],
[paint.width, 0],
[0, paint.height],
[paint.width, paint.height],
]
)
max_x, max_y = corners.max(axis=0).astype(int)
min_x, min_y = corners.min(axis=0).astype(int)
w, h = max_x - min_x, max_y - min_y
offsets -= [min_x, min_y]
pat = np.zeros((w + 1, h + 1, 4))
pat = canvas_merge_at(pat, pat_layer.image, (pat_layer.x - min_x, pat_layer.y - min_y))
image = canvas_compose(COMPOSE_IN, mask.image, pat[offsets[..., 0], offsets[..., 1]])
output = Layer(
image, mask.offset, pre_alpha=pat_layer.pre_alpha, linear_rgb=pat_layer.linear_rgb
)
else:
warnings.warn(f"fill method is not implemented: {paint}")
return None
return output, hull
def stroke(self, width, linecap=None, linejoin=None) -> "Path":
"""Convert path to stroked path"""
curve_names = {2: PATH_LINE, 3: PATH_QUAD, 4: PATH_CUBIC}
dist = width / 2
outputs = []
for path in self:
if not path:
continue
# offset curves
forward, backward = [], []
for cmd, args in path:
if cmd == PATH_LINE or cmd == PATH_CLOSED:
line = np.array(args)
line_forward = line_offset(line, dist)
if line_forward is None:
continue
forward.append(line_forward)
backward.append(line_offset(line, -dist))
elif cmd == PATH_CUBIC:
cubic = np.array(args)
forward.extend(bezier3_offset(cubic, dist))
backward.extend(bezier3_offset(cubic, -dist))
elif cmd == PATH_QUAD:
cubic = bezier2_to_bezier3(args)
forward.extend(bezier3_offset(cubic, dist))
backward.extend(bezier3_offset(cubic, -dist))
elif cmd == PATH_ARC:
for cubic in arc_to_bezier3(*args):
forward.extend(bezier3_offset(cubic, dist))
backward.extend(bezier3_offset(cubic, -dist))
elif cmd == PATH_UNCLOSED:
continue
else:
raise ValueError(f"unsupported path type: `{cmd}`")
closed = cmd == PATH_CLOSED
if not forward:
continue
# connect curves
curves = []
for curve in forward:
if not curves:
curves.append(curve)
continue
curves.extend(stroke_line_join(curves[-1], curve, linejoin))
curves.append(curve)
# complete subpath if path is closed or add line cap
if closed:
curves.extend(stroke_line_join(curves[-1], curves[0], linejoin))
outputs.append([(curve_names[len(curve)], np.array(curve)) for curve in curves])
curves = []
else:
curves.extend(stroke_line_cap(curves[-1][-1], backward[-1][-1], linecap))
# extend subpath with backward path
while backward:
curve = list(reversed(backward.pop()))
if not curves:
curves.append(curve)
continue
curves.extend(stroke_line_join(curves[-1], curve, linejoin))
curves.append(curve)
# complete subpath
if closed:
curves.extend(stroke_line_join(curves[-1], curves[0], linejoin))
else:
curves.extend(stroke_line_cap(curves[-1][-1], curves[0][0], linecap))
outputs.append([(curve_names[len(curve)], np.array(curve)) for curve in curves])
return Path(outputs)
def transform(self, transform: Transform) -> "Path":
"""Apply transformation to a path
This method is usually not used directly but rather transformation is
passed to mask/fill method.
"""
paths_out = []
for path_in in self.subpaths:
path_out = []
if not path_in:
continue
for cmd, args in path_in:
if cmd == PATH_ARC:
cubics = arc_to_bezier3(*args)
for cubic in transform(cubics):
path_out.append((PATH_CUBIC, cubic.tolist()))
else:
points = transform(np.array(args)).tolist()
path_out.append((cmd, points))
paths_out.append(path_out)
return Path(paths_out)
def to_svg(self) -> str:
"""Convert to SVG path"""
output = io.StringIO()
for path in self.subpaths:
if not path:
continue
cmd_prev = None
for cmd, args in path:
if cmd == PATH_LINE:
(x0, y0), (x1, y1) = args
if cmd_prev != cmd:
if cmd_prev is None:
output.write(f"M{x0:g},{y0:g} ")
else:
output.write("L")
output.write(f"{x1:g},{y1:g} ")
cmd_prev = PATH_LINE
elif cmd == PATH_QUAD:
(x0, y0), (x1, y1), (x2, y2) = args
if cmd_prev != cmd:
if cmd_prev is None:
output.write(f"M{x0:g},{y0:g} ")
output.write("Q")
output.write(f"{x1:g},{y1:g} {x2:g},{y2:g} ")
cmd_prev = PATH_QUAD
elif cmd in {PATH_CUBIC, PATH_ARC}:
if cmd == PATH_ARC:
cubics = arc_to_bezier3(*args)
else:
cubics = [args]
for args in cubics:
(x0, y0), (x1, y1), (x2, y2), (x3, y3) = args
if cmd_prev != cmd:
if cmd_prev is None:
output.write(f"M{x0:g},{y0:g} ")
output.write("C")
output.write(f"{x1:g},{y1:g} {x2:g},{y2:g} {x3:g},{y3:g} ")
cmd_prev = PATH_CUBIC
elif cmd == PATH_CLOSED:
output.write("Z ")
cmd_prev = None
elif cmd == PATH_UNCLOSED:
cmd_prev = None
else:
raise ValueError("unhandled path type: `{cmd}`")
output.write("\n")
return output.getvalue()[:-1]
@staticmethod
def from_svg(input: str) -> "Path":
"""Parse SVG path
For more info see [SVG spec](https://www.w3.org/TR/SVG11/paths.html)
"""
input_len = len(input)
input_offset = 0
WHITESPACE = set(" \t\r\n,")
COMMANDS = set("MmZzLlHhVvCcSsQqTtAa")
def position(is_relative, pos, dst):
return [pos[0] + dst[0], pos[1] + dst[1]] if is_relative else dst
def smooth(points):
px, py = points[-1]
cx, cy = points[-2]
return [px * 2 - cx, py * 2 - cy]
# parser state
paths = []
path = []
args = []
cmd = None
pos = [0.0, 0.0]
first = True # true if this is a frist command
start = [0.0, 0.0]
smooth_cubic = None
smooth_quad = None
while input_offset <= input_len:
char = input[input_offset] if input_offset < input_len else None
if char in WHITESPACE:
# remove whitespaces
input_offset += 1
elif char is None or char in COMMANDS:
# process current command
cmd_args, args = args, []
if cmd is None:
pass
elif cmd in "Mm":
# terminate current path
if path:
path.append((PATH_UNCLOSED, [pos, start]))
paths.append(path)
path = []
is_relative = cmd == "m"
(move, *lineto) = chunk(cmd_args, 2)
pos = position(is_relative and not first, pos, move)
start = pos
for dst in lineto:
dst = position(is_relative, pos, dst)
path.append((PATH_LINE, [pos, dst]))
pos = dst
# line to
elif cmd in "Ll":
for dst in chunk(cmd_args, 2):
dst = position(cmd == "l", pos, dst)
path.append((PATH_LINE, [pos, dst]))
pos = dst
# vertical line to
elif cmd in "Vv":
if not cmd_args:
raise ValueError(f"command '{cmd}' expects at least one argument")
is_relative = cmd == "v"
for dst in cmd_args:
dst = position(is_relative, pos, [0 if is_relative else pos[0], dst])
path.append((PATH_LINE, [pos, dst]))
pos = dst
# horizontal line to
elif cmd in "Hh":
if not cmd_args:
raise ValueError(f"command '{cmd}' expects at least one argument")
is_relative = cmd == "h"
for dst in cmd_args:
dst = position(is_relative, pos, [dst, 0 if is_relative else pos[1]])
path.append((PATH_LINE, [pos, dst]))
pos = dst
# cubic bezier curve
elif cmd in "Cc":
for points in chunk(cmd_args, 6):
points = [position(cmd == "c", pos, point) for point in chunk(points, 2)]
path.append((PATH_CUBIC, [pos, *points]))
pos = points[-1]
smooth_cubic = smooth(points)
# smooth cubic bezier curve
elif cmd in "Ss":
for points in chunk(cmd_args, 4):
points = [position(cmd == "s", pos, point) for point in chunk(points, 2)]
if smooth_cubic is None:
smooth_cubic = pos
path.append((PATH_CUBIC, [pos, smooth_cubic, *points]))
pos = points[-1]
smooth_cubic = smooth(points)
# quadratic bezier curve
elif cmd in "Qq":
for points in chunk(cmd_args, 4):
points = [position(cmd == "q", pos, point) for point in chunk(points, 2)]
path.append((PATH_QUAD, [pos, *points]))
pos = points[-1]
smooth_quad = smooth(points)
# smooth quadratic bezier curve
elif cmd in "Tt":
for points in chunk(cmd_args, 2):
points = position(cmd == "t", pos, points)
if smooth_quad is None:
smooth_quad = pos
points = [pos, smooth_quad, points]
path.append((PATH_QUAD, points))
pos = points[-1]
smooth_quad = smooth(points)
# elliptical arc
elif cmd in "Aa":
# NOTE: `large_f`, and `sweep_f` are not float but flags which can only be
# 0 or 1 and as the result some svg minimizers merge them with next
# float which may break current parser logic.
for points in chunk(cmd_args, 7):
rx, ry, x_axis_rot, large_f, sweep_f, dst_x, dst_y = points
dst = position(cmd == "a", pos, [dst_x, dst_y])
src, pos = pos, dst
if rx == 0 or ry == 0:
path.append((PATH_LINE, [pos, dst]))
else:
path.append(
(
PATH_ARC,
arc_svg_to_parametric(
src,
dst,
rx,
ry,
x_axis_rot,
large_f > 0.001,
sweep_f > 0.001,
),
)
)
# close current path
elif cmd in "Zz":
if cmd_args:
raise ValueError(f"`z` command does not accept any argmuents: {cmd_args}")
path.append((PATH_CLOSED, [pos, start]))
if path:
paths.append(path)
path = []
pos = start
else:
raise ValueError(f"unsuppported command '{cmd}' at: {input_offset}")
if cmd is not None and cmd not in "CcSs":
smooth_cubic = None
if cmd is not None and cmd not in "QqTt":
smooth_quad = None
first = False
input_offset += 1
cmd = char
else:
# parse float arguments
match = FLOAT_RE.match(input, input_offset)
if match:
match_str = match.group(0)
args.append(float(match_str))
input_offset += len(match_str)
else:
raise ValueError(f"not recognized command '{char}' at: {input_offset}")
if path:
path.append((PATH_UNCLOSED, [pos, start]))
paths.append(path)
return Path(paths)
def is_empty(self):
return not bool(self.subpaths)
def __repr__(self):
if not self.subpaths:
return "EMPTY"
output = io.StringIO()
for subpath in self.subpaths:
for type, coords in subpath:
if type == PATH_LINE:
output.write(f"LINE {repr_coords(coords)}\n")
elif type == PATH_CUBIC:
output.write(f"CUBIC {repr_coords(coords)}\n")
elif type == PATH_QUAD:
output.write(f"QUAD {repr_coords(coords)}\n")
elif type == PATH_ARC:
center, rx, ry, phi, eta, eta_delta = coords
output.write(f"ARC ")
output.write(f"{repr_coords([center])} ")
output.write(f"{rx:.4g} {ry:.4g} ")
output.write(f"{phi:.3g} {eta:.3g} {eta_delta:.3g}\n")
elif type == PATH_CLOSED:
output.write("CLOSE\n")
return output.getvalue()[:-1]
def repr_coords(coords):
return " ".join(f"{x:.4g},{y:.4g}" for x, y in coords)
# offset along tanget to approximate circle with four bezier3 curves
CIRCLE_BEIZER_OFFSET = 4 * (math.sqrt(2) - 1) / 3
def stroke_line_cap(p0, p1, linecap=None):
"""Generate path connecting two curves p0 and p1 with a cap"""
if linecap is None:
linecap = STROKE_CAP_BUTT
if np.allclose(p0, p1):
return []
if linecap == STROKE_CAP_BUTT:
return [np.array([p0, p1])]
elif linecap == STROKE_CAP_ROUND:
seg = p1 - p0
radius = np.linalg.norm(seg) / 2
seg /= 2 * radius
seg_norm = np.array([-seg[1], seg[0]])
offset = CIRCLE_BEIZER_OFFSET * radius
center = (p0 + p1) / 2
midpoint = center + seg_norm * radius
return [
np.array([p0, p0 + seg_norm * offset, midpoint - seg * offset, midpoint]),
np.array([midpoint, midpoint + seg * offset, p1 + seg_norm * offset, p1]),
]
elif linecap == STROKE_CAP_SQUARE:
seg = p1 - p0
seg_norm = np.array([-seg[1], seg[0]])
polyline = [p0, p0 + seg_norm / 2, p1 + seg_norm / 2, p1]
return [np.array([s0, s1]) for s0, s1 in zip(polyline, polyline[1:])]
else:
raise ValueError(f"unkown line cap type: `{linecap}`")
def stroke_line_join(c0, c1, linejoin=None, miterlimit=4):
"""Stroke used at the joints of paths"""
if linejoin is None:
linejoin = STROKE_JOIN_MITER
if linejoin == STROKE_JOIN_BEVEL:
return [np.array([c0[-1], c1[0]])]
_, l0 = stroke_curve_tangent(c0)
l1, _ = stroke_curve_tangent(c1)
if l0 is None or l1 is None:
return [np.array([c0[-1], c1[0]])]
if np.allclose(l0[-1], l1[0]):
return []
p, t0, t1 = line_intersect(l0, l1)
if p is None or (0 <= t0 <= 1 and 0 <= t1 <= 1):
# curves intersect or parallel
return [np.array([c0[-1], c1[0]])]
# FIXME correctly determine miterlength: stroke_width / sin(eta / 2)
if abs(t0) < miterlimit and abs(t1) < miterlimit:
if linejoin == STROKE_JOIN_MITER:
return [np.array([c0[-1], p]), np.array([p, c1[0]])]
elif linejoin == STROKE_JOIN_ROUND:
# FIXME: correctly produce round instead quad curve
return [np.array([c0[-1], p, c1[0]])]
return [np.array([c0[-1], c1[0]])]
def stroke_curve_tangent(curve):
"""Find tangents of a curve at t = 0 and at t = 1 points"""
segs = []
for p0, p1 in zip(curve, curve[1:]):
if np.allclose(p0, p1):
continue
segs.append([p0, p1])
if not segs:
return None, None
return segs[0], segs[-1]
def chunk(vs, size):
"""Chunk list `vs` into chunk of size `size`"""
chunks = [vs[i : i + size] for i in range(0, len(vs), size)]
if not chunks or len(chunks[-1]) != size:
raise ValueError(f"list {vs} can not be chunked in {size}s")
return chunks
# ------------------------------------------------------------------------------
# Gradients
# ------------------------------------------------------------------------------
class GradLinear(NamedTuple):
p0: np.ndarray
p1: np.ndarray
stops: List[Tuple[float, np.ndarray]]
transform: Optional[Transform]
spread: str
bbox_units: bool
linear_rgb: Optional[bool]
def fill(self, pixels, linear_rgb=True):
"""Fill pixels (array of coordinates) with gradient
Returns new array same size as pixels filled with gradient
"""
if self.transform is not None:
pixels = self.transform.invert(pixels)
vec = self.p1 - self.p0
offset = (pixels - self.p0) @ vec / np.dot(vec, vec)
return grad_interpolate(grad_spread(offset, self.spread), self.stops, linear_rgb)
class GradRadial(NamedTuple):
center: np.ndarray
radius: float
fcenter: Optional[np.ndarray]
fradius: float
stops: List[Tuple[float, np.ndarray]]
transform: Optional[Transform]
spread: str
bbox_units: bool
linear_rgb: Optional[bool]
def fill(self, pixels, linear_rgb=True):
"""Fill pixels (array of coordinates) with gradient
Returns new array same size as pixels filled with gradient.
Two circle gradient is an interpolation between two cirles (c0, r0) and (c1, r1),
with center `c(t) = (1 - t) * c0 + t * c1`, and radius `r(t) = (1 - t) * r0 + t * r1`.
If we have a pixel with coordinates `p`, we should solve equation for it
`|| c(t) - p || = r(t)` and pick solution corresponding to bigger radius.
Solving this equation for `t`:
|| c(t) - p || = r(t) -> At² - 2Bt + C = 0
where:
cd = c2 - c1
pd = p - c1
rd = r2 - r1
A = cdx ^ 2 + cdy ^ 2 - rd ^ 2
B = pdx * cdx + pdy * cdy + r1 * rd
C = pdx ^2 + pdy ^ 2 - r1 ^ 2
results in:
t = (B +/- (B ^ 2 - A * C).sqrt()) / A
[reference]: https://cgit.freedesktop.org/pixman/tree/pixman/pixman-radial-gradient.c
"""
mask = None
if self.transform is not None:
pixels = self.transform.invert(pixels)
if self.fcenter is None and self.fradius is None:
offset = (pixels - self.center) / self.radius
offset = np.sqrt((offset * offset).sum(axis=-1))
else:
fcenter = self.center if self.fcenter is None else self.fcenter
fradius = self.fradius or 0
# This is SVG 1.1 behaviour. If focal center is outside of circle it
# should be moved inside. But in SVG 2.0 it should produce a cone
# shaped gradient.
# fdist = np.linalg.norm(fcenter - self.center)
# if fdist > self.radius:
# fcenter = self.center + (fcenter - self.center) * self.radius / fdist
cd = self.center - fcenter
pd = pixels - fcenter
rd = self.radius - fradius
a = (cd ** 2).sum() - rd ** 2
b = (pd * cd).sum(axis=-1) + fradius * rd
c = (pd ** 2).sum(axis=-1) - fradius ** 2
det = b * b - a * c
if (det < 0).any():
mask = det >= 0
det = det[mask]
b = b[mask]
c = c[mask]
t0 = np.sqrt(det)
t1 = (b + t0) / a
t2 = (b - t0) / a
if mask is None:
offset = np.maximum(t1, t2)
else:
offset = np.zeros(mask.shape, dtype=FLOAT)
offset[mask] = np.maximum(t1, t2)
if fradius != self.radius:
# exclude negative `r(t)`
mask &= offset > (fradius / (fradius - self.radius))
overlay = grad_interpolate(grad_spread(offset, self.spread), self.stops, linear_rgb)
if mask is not None:
overlay[~mask] = np.array([0, 0, 0, 0])
return overlay
def grad_pixels(viewport):
"""Create pixels matrix to be filled by gradient"""
off_x, off_y, width, height = viewport
xs, ys = np.indices((width, height)).astype(FLOAT)
offset = [off_x + 0.5, off_y + 0.5]
return np.concatenate([xs[..., None], ys[..., None]], axis=2) + offset
def grad_spread(offsets, spread):
if spread == "pad":
return offsets
elif spread == "repeat":
return np.modf(offsets)[0]
elif spread == "reflect":
return np.fabs(np.remainder(offsets + 1.0, 2.0) - 1.0)
raise ValueError(f"invalid spread method: {spread}")
def grad_interpolate(offset, stops, linear_rgb):
"""Create gradient by interpolating offsets from stops"""
stops = grad_stops_colorspace(stops, linear_rgb)
output = np.zeros((*offset.shape, 4), dtype=FLOAT)
o_min, c_min = stops[0]
output[offset <= o_min] = c_min
o_max, c_max = stops[-1]
output[offset > o_max] = c_max
for (o0, c0), (o1, c1) in zip(stops, stops[1:]):
mask = np.logical_and(offset > o0, offset <= o1)
ratio = ((offset[mask] - o0) / (o1 - o0))[..., None]
output[mask] += (1 - ratio) * c0 + ratio * c1
return output
def grad_stops_colorspace(stops, linear_rgb=False):
if linear_rgb:
return stops
output = []
for offset, color in stops:
color = color_pre_to_straight_alpha(color.copy())
color = color_linear_to_srgb(color)
color = color_straight_to_pre_alpha(color)
output.append((offset, color))
return output
class Pattern(NamedTuple):
scene: Scene
scene_bbox_units: bool
scene_view_box: Optional[Tuple[float, float, float, float]]
x: float
y: float
width: float
height: float
transform: Transform
bbox_units: bool
def bbox(self):
return (self.x, self.y, self.width, self.height)
# ------------------------------------------------------------------------------
# Filter
# ------------------------------------------------------------------------------
FE_BLEND = 0
FE_COLOR_MATRIX = 1
FE_COMPONENT_TRANSFER = 2
FE_COMPOSITE = 3
FE_CONVOLVE_MATRIX = 4
FE_DIFFUSE_LIGHTING = 5
FE_DISPLACEMENT_MAP = 6
FE_FLOOD = 7
FE_GAUSSIAN_BLUR = 8
FE_MERGE = 9
FE_MORPHOLOGY = 10
FE_OFFSET = 11
FE_SPECULAR_LIGHTING = 12
FE_TILE = 13
FE_TURBULENCE = 14
FE_SOURCE_ALPHA = "SourceAlpha"
FE_SOURCE_GRAPHIC = "SourceGraphic"
COLOR_MATRIX_LUM = np.array(
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0.2125, 0.7154, 0.0721, 0, 0]], dtype=FLOAT
)
COLOR_MATRIX_HUE = np.array(
[
[[0.213, 0.715, 0.072], [0.213, 0.715, 0.072], [0.213, 0.715, 0.072]],
[[0.787, -0.715, -0.072], [-0.213, 0.285, -0.072], [-0.213, -0.715, 0.928]],
[[-0.213, -0.715, 0.928], [0.143, 0.140, -0.283], [-0.787, 0.715, 0.072]],
],
dtype=FLOAT,
)
class Filter(NamedTuple):
names: Dict[str, int] # {name: index}
filters: List[Tuple[int, List[Any], List[int]]] # [(type, attrs, inputs)]
@classmethod
def empty(cls):
return cls({FE_SOURCE_ALPHA: 0, FE_SOURCE_GRAPHIC: 1}, [])
def add_filter(self, type, attrs, inputs, result):
names = self.names.copy()
filters = self.filters.copy()
args = []
for input in inputs:
if input is None:
args.append(len(filters) + 1) # use previous result
else:
arg = self.names.get(input)
if arg is None:
warnings.warn(f"unknown filter result name: {input}")
args.append(len(filters) + 1) # use previous result
else:
args.append(arg)
if result is not None:
names[result] = len(filters) + 2
filters.append((type, attrs, args))
return Filter(names, filters)
def offset(self, dx, dy, input=None, result=None):
return self.add_filter(FE_OFFSET, (dx, dy), [input], result)
def merge(self, inputs, result=None):
return self.add_filter(FE_MERGE, tuple(), inputs, result)
def blur(self, std_x, std_y=None, input=None, result=None):
return self.add_filter(FE_GAUSSIAN_BLUR, (std_x, std_y), [input], result)
def blend(self, in1, in2, mode=None, result=None):
return self.add_filter(FE_BLEND, (mode,), [in1, in2], result)
def composite(self, in1, in2, mode=None, result=None):
return self.add_filter(FE_COMPOSITE, (mode,), [in1, in2], result)
def color_matrix(self, input, matrix, result=None):
return self.add_filter(FE_COLOR_MATRIX, (matrix,), [input], result)
def morphology(self, rx, ry, method, input, result=None):
return self.add_filter(FE_MORPHOLOGY, (rx, ry, method), [input], result)
def __call__(self, transform, source):
"""Execute fiter on the provided source"""
alpha = Layer(
source.image[..., -1:] * np.array([0, 0, 0, 1]),
source.offset,
pre_alpha=True,
linear_rgb=True,
)
stack = [alpha, source.convert(pre_alpha=False, linear_rgb=True)]
for filter in self.filters:
type, attrs, inputs = filter
if type == FE_OFFSET:
fn = filter_offset(transform, *attrs)
elif type == FE_MERGE:
fn = filter_merge(transform, *attrs)
elif type == FE_BLEND:
fn = filter_blend(transform, *attrs)
elif type == FE_COMPOSITE:
fn = filter_composite(transform, *attrs)
elif type == FE_GAUSSIAN_BLUR:
fn = filter_blur(transform, *attrs)
elif type == FE_COLOR_MATRIX:
fn = filter_color_matrix(transform, *attrs)
elif type == FE_MORPHOLOGY:
fn = filter_morphology(transform, *attrs)
else:
raise ValueError(f"unsupported filter type: {type}")
stack.append(fn(*(stack[input] for input in inputs)))
return stack[-1]
def filter_color_matrix(_transform, matrix):
def filter_color_matrix_apply(input):
if not isinstance(matrix, np.ndarray) or matrix.shape != (4, 5):
warnings.warn(f"invalid color matrix: {matrix}")
return input
return input.color_matrix(matrix)
return filter_color_matrix_apply
def filter_offset(transform, dx, dy):
def filter_offset_apply(input):
x, y = input.offset
tx, ty = transform(transform.invert([x, y]) + [dx, dy])
return input.translate(int(tx) - x, int(ty) - y)
return filter_offset_apply
def filter_morphology(transform, rx, ry, method):
def filter_morphology_apply(input):
# NOTE:
# I have no idea how to account for rotation, except to roate
# apply morphology and rotate back, but it is slow, so I'm not doing it
ux, uy = transform([[rx, 0], [0, ry]]) - transform([[0, 0], [0, 0]])
x = int(np.linalg.norm(ux) * 2)
y = int(np.linalg.norm(uy) * 2)
if x < 1 or y < 1:
return input
return input.morphology(x, y, method)
return filter_morphology_apply
def filter_merge(_transform):
def filter_merge_apply(*inputs):
return Layer.compose(inputs, linear_rgb=True)
return filter_merge_apply
def filter_blend(_transform, mode):
def filter_blend_apply(in1, in2):
warnings.warn("feBlend is not properly supported")
return Layer.compose([in2, in1], linear_rgb=True)
return filter_blend_apply
def filter_composite(_transform, mode):
def filter_composite_apply(in1, in2):
return Layer.compose([in2, in1], mode, linear_rgb=True)
return filter_composite_apply
def filter_blur(transform, std_x, std_y=None):
if std_y is None:
std_y = std_x
def filter_blur_apply(input):
kernel = blur_kernel(transform, (std_x, std_y))
if kernel is None:
return input
return input.convolve(kernel)
return filter_blur_apply
def blur_kernel(transform, sigma):
"""Gaussian blur convolution kerenel
Gaussiange kernel ginven presentation transformation and sigma in user
coordinate system.
"""
sigma_x, sigma_y = sigma
# if one of the sigmas is smaller then a pixel rotatetion produces
# incorrect degenerate state when the whole convolution is the same as over
# a delta function. So we need to adjust it. If both simgas are smallerd
# then a pixel then gaussian blur is a nonop.
scale_x, scale_y = np.linalg.norm(transform(np.eye(2)) - transform([0, 0]), axis=1)
if scale_x * sigma_x < 0.5 and scale_y * sigma_y < 0.5:
return None
elif scale_x * sigma_x < 0.5:
sigma_x = 0.5 / scale_x
elif scale_y * sigma_y < 0.5:
sigma_y = 0.5 / scale_y
sigma = np.array([sigma_x, sigma_y])
sigmas = 2.5
user_box = [
[-sigmas * sigma_x, -sigmas * sigma_y],
[-sigmas * sigma_x, sigmas * sigma_y],
[sigmas * sigma_x, sigmas * sigma_y],
[sigmas * sigma_x, -sigmas * sigma_y],
]
box = transform(user_box) - transform([0, 0])
min_x, min_y = box.min(axis=0).astype(int)
max_x, max_y = box.max(axis=0).astype(int)
kernel_w, kernel_h = max_x - min_x, max_y - min_y
kernel_w += ~kernel_w & 1 # make it odd
kernel_h += ~kernel_h & 1
user_tr = transform.invert
kernel = user_tr(grad_pixels([-kernel_w / 2, -kernel_h / 2, kernel_w, kernel_h]))
kernel -= user_tr([0, 0]) # remove translation
kernel = np.exp(- | np.square(kernel) | numpy.square |
import time
import random
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import ops.semantic_segmentation.imageops as imageops
def test(predict, dataset, num_classes,
batch_size=3, ys_mask=None, cutoffs=(0.0, 0.9), bins=np.linspace(0.0, 1.0, 11), verbose=True, period=10):
predict_times = []
nll_metric = tf.keras.metrics.SparseCategoricalCrossentropy(name='nll')
cm_shape = [num_classes, num_classes]
cms = [[np.zeros(cm_shape), np.zeros(cm_shape)] for _ in range(len(cutoffs))]
ious, accs, uncs, covs, eces = [], [], [], [], []
cms_bin = [np.zeros(cm_shape) for _ in range(len(bins) - 1)]
confs_metric_bin = [tf.keras.metrics.Mean() for _ in range(len(bins) - 1)]
count_bin, accs_bin, confs_bin, metrics_str = [], [], [], []
dataset = dataset.batch(batch_size).enumerate().prefetch(tf.data.experimental.AUTOTUNE)
for step, (xs, ys) in dataset:
batch_time = time.time()
ys_pred = predict(xs)
predict_times.append(time.time() - batch_time)
mask = ys_mask(xs, ys)
ys = tf.boolean_mask(ys, mask)
ys_pred = tf.boolean_mask(ys_pred, mask)
nll_metric(ys, ys_pred)
for cutoff, cm_group in zip(cutoffs, cms):
cm_certain = cm(ys, ys_pred, num_classes, filter_min=cutoff)
cm_uncertain = cm(ys, ys_pred, num_classes, filter_max=cutoff)
cm_group[0] = cm_group[0] + cm_certain
cm_group[1] = cm_group[1] + cm_uncertain
for i, (start, end) in enumerate(zip(bins, bins[1:])):
cms_bin[i] = cms_bin[i] + cm(ys, ys_pred, num_classes, filter_min=start, filter_max=end)
confidence = tf.math.reduce_max(ys_pred, axis=-1)
condition = tf.logical_and(confidence >= start, confidence < end)
confs_metric_bin[i](tf.boolean_mask(confidence, condition))
ious = [miou(cm_certain) for cm_certain, cm_uncertain in cms]
accs = [gacc(cm_certain) for cm_certain, cm_uncertain in cms]
uncs = [unconfidence(cm_certain, cm_uncertain) for cm_certain, cm_uncertain in cms]
covs = [coverage(cm_certain, cm_uncertain) for cm_certain, cm_uncertain in cms]
count_bin = [np.sum(cm_bin) for cm_bin in cms_bin]
accs_bin = [gacc(cm_bin) for cm_bin in cms_bin]
confs_bin = [metric.result() for metric in confs_metric_bin]
eces = ece(count_bin, accs_bin, confs_bin)
metrics_str = [
"Time: %.3f ± %.3f ms" % (np.mean(predict_times) * 1e3, np.std(predict_times) * 1e3),
"NLL: %.4f" % nll_metric.result(),
"Cutoffs: " + ", ".join(["%.1f %%" % (cutoff * 100) for cutoff in cutoffs]),
"Accs: " + ", ".join(["%.3f %%" % (acc * 100) for acc in accs]),
"Uncs: " + ", ".join(["%.3f %%" % (unc * 100) for unc in uncs]),
"IoUs: " + ", ".join(["%.3f %%" % (iou * 100) for iou in ious]),
"Covs: " + ", ".join(["%.3f %%" % (cov * 100) for cov in covs]),
"ECE: " + "%.3f %%" % (eces * 100),
]
if verbose and int(step + 1) % period is 0:
print('%d Steps, %s' % (int(step + 1), ', '.join(metrics_str)))
print(", ".join(metrics_str))
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
confidence_histogram(axes[0], count_bin)
reliability_diagram(axes[1], accs_bin)
fig.tight_layout()
calibration_image = imageops.plot_to_image(fig)
if not verbose:
plt.close(fig)
return nll_metric.result(), cms, ious, accs, uncs, covs, \
count_bin, accs_bin, confs_bin, eces, calibration_image
def ys_mask(xs, ys, edge):
# Void mask
mask = ys >= 0
# Edge mask
if edge is not None:
xs_edge = tf.image.sobel_edges(tf.image.rgb_to_grayscale(xs))
xs_edge = tf.squeeze(xs_edge, axis=3)
xs_edge = tf.sqrt(tf.reduce_sum(tf.math.square(xs_edge), axis=-1))
mask = tf.math.logical_and(mask, xs_edge > edge)
return mask
def ys_mask_seq(xs, ys, edge):
# Void mask
mask = ys >= 0
# Edge mask
if edge is not None:
xs_edge = tf.image.sobel_edges(tf.image.rgb_to_grayscale(xs[:, -1, :, :, :]))
xs_edge = tf.squeeze(xs_edge, axis=3)
xs_edge = tf.sqrt(tf.reduce_sum(tf.math.square(xs_edge), axis=-1))
mask = tf.math.logical_and(mask, xs_edge > edge)
return mask
def test_vanilla(model, dataset, num_classes, batch_size=3,
edge=None, cutoffs=(0.0, 0.9), verbose=True, period=10):
return test(lambda xs: predict_vanilla(model, xs), dataset, num_classes, batch_size=batch_size,
ys_mask=lambda xs, ys: ys_mask(xs, ys, edge), cutoffs=cutoffs, verbose=verbose, period=period)
def test_temp_scaling(model, temp, dataset, num_classes, batch_size=3,
edge=None, cutoffs=(0.0, 0.9), verbose=True, period=10):
return test(lambda xs: predict_temp_scaling(model, xs, temp), dataset, num_classes, batch_size=batch_size,
ys_mask=lambda xs, ys: ys_mask(xs, ys, edge), cutoffs=cutoffs, verbose=verbose, period=period)
def test_sampling(model, n_ff, dataset, num_classes, batch_size=3,
edge=None, cutoffs=(0.0, 0.9), verbose=True, period=10):
return test(lambda xs: predict_sampling(model, xs, n_ff), dataset, num_classes, batch_size=batch_size,
ys_mask=lambda xs, ys: ys_mask(xs, ys, edge), cutoffs=cutoffs, verbose=verbose, period=period)
def test_temporal_smoothing(model, l, offset, dataset, num_classes, batch_size=3,
edge=None, cutoffs=(0.0, 0.9), verbose=True, period=10):
return test(lambda xs: predict_temporal_smoothing(model, xs, l, offset), dataset, num_classes, batch_size=batch_size,
ys_mask=lambda xs, ys: ys_mask_seq(xs, ys, edge), cutoffs=cutoffs, verbose=verbose, period=period)
def test_ensemble(models, dataset, num_classes, batch_size=3,
edge=None, cutoffs=(0.0, 0.9), verbose=True, period=10):
return test(lambda xs: predict_ensemble(models, xs), dataset, num_classes, batch_size=batch_size,
ys_mask=lambda xs, ys: ys_mask(xs, ys, edge), cutoffs=cutoffs, verbose=verbose, period=period)
def test_ensemble_smoothing(models, l, dataset, num_classes, batch_size=3,
edge=None, cutoffs=(0.0, 0.9), verbose=True, period=10):
return test(lambda xs: predict_ensemble_smoothing(models, xs, l), dataset, num_classes, batch_size=batch_size,
ys_mask=lambda xs, ys: ys_mask_seq(xs, ys, edge), cutoffs=cutoffs, verbose=verbose, period=period)
def predict_vanilla(model, xs):
ys_pred = tf.nn.softmax(model(xs), axis=-1)
return ys_pred
def predict_temp_scaling(model, xs, temp=1.0):
ys_pred = tf.nn.softmax(model(xs) / temp, axis=-1)
return ys_pred
def predict_sampling(model, xs, n_ff):
ys_pred = tf.stack([tf.nn.softmax(model(xs), axis=-1) for _ in range(n_ff)])
ys_pred = tf.math.reduce_mean(ys_pred, axis=0)
return ys_pred
def predict_temporal_smoothing(model, xs, l, offset):
"""
Shape:
xs: [batch_size, n_ff, H, W, C]
"""
weight = list(range(offset[0])) + list(range(offset[0], offset[0] - offset[1] - 1, -1))
weight = tf.constant(weight, dtype=tf.float32)
weight = weight * l
weight = tf.math.exp(weight)
weight = weight / tf.reduce_sum(weight)
xs = tf.einsum("ij...->ji...", xs) # xs = tf.transpose(xs, perm=[1, 0, ...])
ys_pred = tf.stack([tf.nn.softmax(model(x_batch), axis=-1) for x_batch in xs])
ys_pred = tf.tensordot(weight, ys_pred, axes=[0, 0])
return ys_pred
def predict_ensemble(models, xs):
ys_pred = tf.stack([tf.nn.softmax(model(xs), axis=-1) for model in models])
ys_pred = tf.math.reduce_mean(ys_pred, axis=0)
return ys_pred
def predict_ensemble_smoothing(models, xs, l):
n_ff = xs.shape[1]
weight = (tf.range(n_ff, dtype=tf.float32) - n_ff) * l
weight = tf.math.exp(weight)
weight = weight / tf.reduce_sum(weight)
xs = tf.einsum("ij...->ji...", xs) # xs = tf.transpose(xs, perm=[1, 0, ...])
models = [models[random.randint(0, len(models)) - 1] for _ in range(len(xs))]
ys_pred = tf.stack([tf.nn.softmax(model(x_batch), axis=-1) for model, x_batch in zip(models, xs)])
ys_pred = tf.tensordot(weight, ys_pred, axes=[0, 0])
return ys_pred
def cm(ys, ys_pred, num_classes, filter_min=0.0, filter_max=1.0):
"""
Confusion matrix.
:param ys: [batch_size, height, width]
:param ys_pred: onehot with shape [batch_size, height, width, num_class]
:param num_classes: int
:param filter_min:
:param filter_max:
:return: cms for certain and uncertain prediction (shape: [batch_size, num_classes, num_classes])
"""
ys = tf.reshape(tf.cast(ys, tf.int32), [-1])
result = tf.reshape(tf.argmax(ys_pred, axis=-1, output_type=tf.int32), [-1])
confidence = tf.reshape(tf.math.reduce_max(ys_pred, axis=-1), [-1])
condition = tf.logical_and(confidence > filter_min, confidence <= filter_max)
k = (ys >= 0) & (ys < num_classes) & condition
cm = tf.math.bincount(num_classes * ys[k] + result[k], minlength=num_classes ** 2)
cm = tf.reshape(cm, [num_classes, num_classes])
return cm
def miou(cm):
"""
Mean IoU
"""
weights = np.sum(cm, axis=1)
weights = [1 if weight > 0 else 0 for weight in weights]
if np.sum(weights) > 0:
_miou = np.average(ious(cm), weights=weights)
else:
_miou = 0.0
return _miou
def ious(cm):
"""
Intersection over unit w.r.t. classes.
"""
num = np.diag(cm)
den = np.sum(cm, axis=1) + np.sum(cm, axis=0) - np.diag(cm)
return np.divide(num, den, out=np.zeros_like(num, dtype=float), where=(den != 0))
def gacc(cm):
"""
Global accuracy p(accurate). For cm_certain, p(accurate|confident).
"""
num = np.diag(cm).sum()
den = np.sum(cm)
return np.divide(num, den, out=np.zeros_like(num, dtype=float), where=(den != 0))
def caccs(cm):
"""
Accuracies w.r.t. classes.
"""
accs = []
for ii in range(np.shape(cm)[0]):
if float(np.sum(cm, axis=1)[ii]) == 0:
acc = 0.0
else:
acc = | np.diag(cm) | numpy.diag |
import unittest
import numpy as np
from femio.fem_data import FEMData
from femio.util import brick_generator
WRITE_TEST_DATA = False
class TestBrickGenerator(unittest.TestCase):
def test_generate_brick_tri(self):
n_x_element = 4
n_y_element = 10
x_length = .5
y_length = 2.
fem_data = brick_generator.generate_brick(
'tri', n_x_element, n_y_element,
x_length=x_length, y_length=y_length)
np.testing.assert_almost_equal(
np.max(fem_data.nodes.data, axis=0), [x_length, y_length, 0.])
np.testing.assert_almost_equal(
np.min(fem_data.nodes.data, axis=0), [0., 0., 0.])
self.assertEqual(len(fem_data.elements), n_x_element * n_y_element * 2)
if WRITE_TEST_DATA:
fem_data.write(
'ucd', 'tests/data/ucd/brick_tri/mesh.inp', overwrite=True)
areas = fem_data.calculate_element_areas()
np.testing.assert_almost_equal(
areas, (x_length / n_x_element) * (y_length / n_y_element) / 2)
ref_fem_data = FEMData.read_directory(
'ucd', 'tests/data/ucd/brick_tri', read_npy=False, save=False)
np.testing.assert_almost_equal(
fem_data.nodes.data, ref_fem_data.nodes.data)
np.testing.assert_array_equal(
fem_data.elements.data, ref_fem_data.elements.data)
def test_generate_brick_quad(self):
n_x_element = 4
n_y_element = 20
x_length = 1.
y_length = 4.
fem_data = brick_generator.generate_brick(
'quad', n_x_element, n_y_element,
x_length=x_length, y_length=y_length)
np.testing.assert_almost_equal(
np.max(fem_data.nodes.data, axis=0), [x_length, y_length, 0.])
np.testing.assert_almost_equal(
| np.min(fem_data.nodes.data, axis=0) | numpy.min |
"""
Dictionary learning estimator: Perform a map learning algorithm by learning
a temporal dense dictionary along with sparse spatial loadings, that
constitutes output maps
"""
# Author: <NAME>
# License: BSD 3 clause
from __future__ import division
import warnings
from distutils.version import LooseVersion
import numpy as np
import sklearn
from sklearn.base import TransformerMixin
from sklearn.decomposition import dict_learning_online
from sklearn.externals.joblib import Memory
from sklearn.linear_model import Ridge
from .base import BaseDecomposition, mask_and_reduce
from .canica import CanICA
if LooseVersion(sklearn.__version__) >= LooseVersion('0.17'):
# check_input=False is an optimization available only in sklearn >=0.17
sparse_encode_args = {'check_input': False}
def _compute_loadings(components, data):
ridge = Ridge(fit_intercept=None, alpha=1e-8)
ridge.fit(components.T, np.asarray(data.T))
loadings = ridge.coef_.T
S = np.sqrt(np.sum(loadings ** 2, axis=0))
S[S == 0] = 1
loadings /= S[np.newaxis, :]
return loadings
class DictLearning(BaseDecomposition, TransformerMixin):
"""Perform a map learning algorithm based on spatial component sparsity,
over a CanICA initialization. This yields more stable maps than CanICA.
.. versionadded:: 0.2
Parameters
----------
mask: Niimg-like object or MultiNiftiMasker instance, optional
Mask to be used on data. If an instance of masker is passed,
then its mask will be used. If no mask is given,
it will be computed automatically by a MultiNiftiMasker with default
parameters.
n_components: int
Number of components to extract.
batch_size : int, optional, default=20
The number of samples to take in each batch.
n_epochs: float
Number of epochs the algorithm should run on the data.
alpha: float, optional, default=1
Sparsity controlling parameter.
dict_init: Niimg-like object, optional
Initial estimation of dictionary maps. Would be computed from CanICA if
not provided.
reduction_ratio: 'auto' or float between 0. and 1.
- Between 0. or 1. : controls data reduction in the temporal domain.
1. means no reduction, < 1. calls for an SVD based reduction.
- if set to 'auto', estimator will set the number of components per
reduced session to be n_components.
method : {'lars', 'cd'}
Coding method used by sklearn backend. Below are the possible values.
lars: uses the least angle regression method to solve the lasso problem
(linear_model.lars_path)
cd: uses the coordinate descent method to compute the
Lasso solution (linear_model.Lasso). Lars will be faster if
the estimated components are sparse.
random_state: int or RandomState
Pseudo number generator state used for random sampling.
smoothing_fwhm: float, optional
If smoothing_fwhm is not None, it gives the size in millimeters of the
spatial smoothing to apply to the signal.
standardize : boolean, optional
If standardize is True, the time-series are centered and normed:
their variance is put to 1 in the time dimension.
target_affine: 3x3 or 4x4 matrix, optional
This parameter is passed to image.resample_img. Please see the
related documentation for details.
target_shape: 3-tuple of integers, optional
This parameter is passed to image.resample_img. Please see the
related documentation for details.
low_pass: None or float, optional
This parameter is passed to signal.clean. Please see the related
documentation for details.
high_pass: None or float, optional
This parameter is passed to signal.clean. Please see the related
documentation for details.
t_r: float, optional
This parameter is passed to signal.clean. Please see the related
documentation for details.
memory: instance of joblib.Memory or string
Used to cache the masking process.
By default, no caching is done. If a string is given, it is the
path to the caching directory.
memory_level: integer, optional
Rough estimator of the amount of memory used by caching. Higher value
means more memory for caching.
n_jobs: integer, optional, default=1
The number of CPUs to use to do the computation. -1 means
'all CPUs', -2 'all CPUs but one', and so on.
verbose: integer, optional
Indicate the level of verbosity. By default, nothing is printed.
References
----------
* <NAME>, <NAME>, <NAME>,
Compressed online dictionary learning for fast resting-state fMRI
decomposition.
IEEE 13th International Symposium on Biomedical Imaging (ISBI), 2016.
pp. 1282-1285
"""
def __init__(self, n_components=20,
n_epochs=1, alpha=10, reduction_ratio='auto', dict_init=None,
random_state=None, batch_size=20, method="cd", mask=None,
smoothing_fwhm=4, standardize=True, detrend=True,
low_pass=None, high_pass=None, t_r=None, target_affine=None,
target_shape=None, mask_strategy='epi', mask_args=None,
n_jobs=1, verbose=0, memory=Memory(cachedir=None),
memory_level=0):
BaseDecomposition.__init__(self, n_components=n_components,
random_state=random_state, mask=mask,
smoothing_fwhm=smoothing_fwhm,
standardize=standardize, detrend=detrend,
low_pass=low_pass, high_pass=high_pass,
t_r=t_r, target_affine=target_affine,
target_shape=target_shape,
mask_strategy=mask_strategy,
mask_args=mask_args, memory=memory,
memory_level=memory_level, n_jobs=n_jobs,
verbose=verbose)
self.n_epochs = n_epochs
self.batch_size = batch_size
self.method = method
self.alpha = alpha
self.reduction_ratio = reduction_ratio
self.dict_init = dict_init
def _init_dict(self, data):
if self.dict_init is not None:
components = self.masker_.transform(self.dict_init)
else:
canica = CanICA(n_components=self.n_components,
# CanICA specific parameters
do_cca=True, threshold=float(self.n_components),
n_init=1,
# mask parameter is not useful as we bypass masking
mask=self.masker_, random_state=self.random_state,
memory=self.memory, memory_level=self.memory_level,
n_jobs=self.n_jobs, verbose=self.verbose)
with warnings.catch_warnings():
warnings.simplefilter("ignore", UserWarning)
# We use protected function _raw_fit as data
# has already been unmasked
canica._raw_fit(data)
components = canica.components_
S = (components ** 2).sum(axis=1)
S[S == 0] = 1
components /= S[:, np.newaxis]
self.components_init_ = components
def _init_loadings(self, data):
self.loadings_init_ = self._cache(_compute_loadings)(
self.components_init_, data)
def fit(self, imgs, y=None, confounds=None):
"""Compute the mask and component maps across subjects
Parameters
----------
imgs: list of Niimg-like objects
See http://nilearn.github.io/manipulating_images/input_output.html
Data on which PCA must be calculated. If this is a list,
the affine is considered the same for all.
confounds: CSV file path or 2D matrix
This parameter is passed to nilearn.signal.clean. Please see the
related documentation for details
"""
# Base logic for decomposition estimators
BaseDecomposition.fit(self, imgs)
if self.verbose:
print('[DictLearning] Loading data')
data = mask_and_reduce(self.masker_, imgs, confounds,
reduction_ratio=self.reduction_ratio,
n_components=self.n_components,
random_state=self.random_state,
memory_level=max(0, self.memory_level - 1),
n_jobs=self.n_jobs, memory=self.memory)
if self.verbose:
print('[DictLearning] Learning initial components')
self._init_dict(data)
self._raw_fit(data)
return self
def _raw_fit(self, data):
"""Helper function that direcly process unmasked data
Parameters
----------
data: ndarray,
Shape (n_samples, n_features)
"""
_, n_features = data.shape
if self.verbose:
print('[DictLearning] Computing initial loadings')
self._init_loadings(data)
dict_init = self.loadings_init_
n_iter = ((n_features - 1) // self.batch_size + 1) * self.n_epochs
if self.verbose:
print('[DictLearning] Learning dictionary')
self.components_, _ = self._cache(dict_learning_online)(
data.T, self.n_components, alpha=self.alpha, n_iter=n_iter,
batch_size=self.batch_size, method=self.method,
dict_init=dict_init, verbose=max(0, self.verbose - 1),
random_state=self.random_state, return_code=True, shuffle=True,
n_jobs=1)
self.components_ = self.components_.T
# Unit-variance scaling
S = np.sqrt( | np.sum(self.components_ ** 2, axis=1) | numpy.sum |
# Built-in
import sys
import os
import warnings
import inspect
# Common
import numpy as np
# tofu
import tofu
try:
import tofu.geom._core as _core
except Exception:
from . import _core
__all__ = ['coords_transform',
'get_nIne1e2', 'get_X12fromflat',
'compute_RaysCones',
'get_available_config', 'create_config',
'create_CamLOS1D', 'create_CamLOS2D']
_sep = '_'
_dict_lexcept_key = []
_lok = np.arange(0,9)
_lok = np.array([_lok, _lok+10])
_root = tofu.__path__[0]
_path_testcases = os.path.join(_root, 'geom', 'inputs')
###########################################################
# COCOS
###########################################################
class CoordinateInputError(Exception):
_cocosref = "<NAME>, <NAME>, "
_cocosref += "Computer Physics Communications 184 (2103) 293-302"
msg = "The provided coords flag should be a str\n"
msg += "It should match a known flag:\n"
msg += " - 'cart' / 'xyz' : cartesian coordinates\n"
msg += " - cocos flag indicating the cocos number (1-8, 11-18)\n"
msg += " Valid cocos flags include:\n"
msg += " '11', '02', '5', '14', ..."
msg += "\n"
msg += "The cocos (COordinates COnvetionS) are descibed in:\n"
msg += " [1] %s"%_cocosref
def __init__(self, msg, errors):
# Call the base class constructor with the parameters it
# needs
super(CoordinateInputError, self).__init__(msg + '\n\n' + self.msg)
# Now for your custom code...
self.errors = errors
def _coords_checkformatcoords(coords='11'):
if not type(coords) is str:
msg = "Arg coords must be a str !"
raise CoordinateInputError(msg)
coords = coords.lower()
iint = np.array([ss.isdigit() for ss in coords]).nonzero()[0]
if coords in ['cart','xyz']:
coords = 'xyz'
elif iint.size in [1,2]:
coords = int(''.join([coords[jj] for jj in iint]))
if not coords in _lok.ravel():
msg = 'Not allowed number ({0) !'.format(coords)
raise CoordinateInputError(msg)
else:
msg = "Not allowed coords ({0}) !".format(coords)
raise CoordinateInputError(msg)
return coords
def _coords_cocos2cart(pts, coords=11):
R = pts[0,:]
if (coords%0)%2==1:
indphi, indZi, sig = 1, 2, 1.
else:
indphi, indZ , sig= 2, 1, -1.
phi = sig*pts[indphi,:]
X = R*np.cos(phi)
Y = R*np.sin(phi)
Z = pts[indZ,:]
return np.array([X,Y,Z])
def _coords_cart2cocos(pts, coords=11):
R = np.hypot(pts[0,:],pts[1,:])
phi = np.arctan2(pts[1,:],pts[0,:])
Z = pts[2,:]
if (coords%0)%2==1:
indphi, indZ, sig = 1, 2, 1.
else:
indphi, indZ , sig= 2, 1, -1.
pts_out = np.empty((3,pts.shape[1]),dtype=float)
pts_out[0,:] = R
pts_out[indphi,:] = sig*phi
pts_out[indZ,:] = Z
return pts_out
def coords_transform(pts, coords_in='11', coords_out='11'):
coords_in = _coords_checkformatcoords(coords=coords_in)
coords_out = _coords_checkformatcoords(coords=coords_out)
if coords_in==coords_out:
pass
elif coords_in=='xyz':
pts = _coords_cart2cocos(pts, coords_out)
elif coords_out=='xyz':
pts = _coords_cocos2cart(pts, coords_out)
else:
pts = _coords_cocos2cart(pts, coords_in)
pts = _coords_cocos2cart(pts, coords_out)
return pts
###########################################################
###########################################################
# Useful functions
###########################################################
def get_nIne1e2(P, nIn=None, e1=None, e2=None):
assert np.hypot(P[0],P[1])>1.e-12
phi = np.arctan2(P[1],P[0])
ephi = np.array([-np.sin(phi), np.cos(phi), 0.])
ez = np.array([0.,0.,1.])
if nIn is None:
nIn = -P
nIn = nIn / np.linalg.norm(nIn)
if e1 is None:
if np.abs(np.abs(nIn[2])-1.) < 1.e-12:
e1 = ephi
else:
e1 = np.cross(nIn,ez)
e1 = e1 if np.sum(e1*ephi) > 0. else -e1
e1 = e1 / np.linalg.norm(e1)
if not np.abs(np.sum(nIn*e1))<1.e-12:
msg = "Identified local base does not seem valid!\n"
msg += "nIn = %s\n"%str(nIn)
msg += "e1 = %s\n"%str(e1)
msg += "np.sum(nIn*e1) = sum(%s) = %s"%(nIn*e1, np.sum(nIn*e1))
raise Exception(msg)
if e2 is None:
e2 = | np.cross(nIn,e1) | numpy.cross |
import numpy as np
from sklearn.cluster import DBSCAN
from faster_particles.ppn_utils import crop as crop_util
from faster_particles.display_utils import extract_voxels
class CroppingAlgorithm(object):
"""
Base class for any cropping algorithm, they should inherit from it
and implement crop method (see below)
"""
def __init__(self, cfg, debug=False):
self.cfg = cfg
self.d = cfg.SLICE_SIZE # Patch or box/crop size
self.a = cfg.CORE_SIZE # Core size
self.N = cfg.IMAGE_SIZE
self._debug = debug
def crop(self, coords):
"""
coords is expected to be dimensions (None, 3) = list of non-zero voxels
Returns a list of patches centers and sizes (of cubes centered at the
patch centers)
"""
pass
def process(self, original_blob):
# FIXME cfg.SLICE_SIZE vs patch_size
patch_centers, patch_sizes = self.crop(original_blob['voxels'])
return self.extract(patch_centers, patch_sizes, original_blob)
def extract(self, patch_centers, patch_sizes, original_blob):
batch_blobs = []
for i in range(len(patch_centers)):
patch_center, patch_size = patch_centers[i], patch_sizes[i]
blob = {}
# Flip patch_center coordinates
# because gt_pixels coordinates are reversed
# FIXME here or before blob['data'] ??
patch_center = np.flipud(patch_center)
blob['data'], _ = crop_util(np.array([patch_center]),
self.cfg.SLICE_SIZE,
original_blob['data'], return_labels=False)
patch_center = patch_center.astype(int)
# print(patch_center, original_blob['data'][0, patch_center[0], patch_center[1], patch_center[2], 0], np.count_nonzero(blob['data']))
# assert np.count_nonzero(blob['data']) > 0
if 'labels' in original_blob:
blob['labels'], _ = crop_util(np.array([patch_center]),
self.cfg.SLICE_SIZE,
original_blob['labels'][..., np.newaxis], return_labels=False)
blob['labels'] = blob['labels'][..., 0]
# print(np.nonzero(blob['data']))
# print(np.nonzero(blob['labels']))
# assert np.array_equal(np.nonzero(blob['data']), np.nonzero(blob['labels']))
if 'weight' in original_blob:
blob['weight'], _ = crop_util(np.array([patch_center]),
self.cfg.SLICE_SIZE,
original_blob['weight'][..., np.newaxis], return_labels=False)
blob['weight'][blob['weight'] == 0.0] = 0.1
blob['weight'] = blob['weight'][..., 0]
# Select gt pixels
if 'gt_pixels' in original_blob:
indices = np.where(np.all(np.logical_and(
original_blob['gt_pixels'][:, :-1] >= patch_center - patch_size/2.0,
original_blob['gt_pixels'][:, :-1] < patch_center + patch_size/2.0), axis=1))
blob['gt_pixels'] = original_blob['gt_pixels'][indices]
blob['gt_pixels'][:, :-1] = blob['gt_pixels'][:, :-1] - (patch_center - patch_size / 2.0)
# Add artificial gt pixels
artificial_gt_pixels = self.add_gt_pixels(original_blob, blob, patch_center, self.cfg.SLICE_SIZE)
if artificial_gt_pixels.shape[0]:
blob['gt_pixels'] = np.concatenate([blob['gt_pixels'], artificial_gt_pixels], axis=0)
# Select voxels
# Flip patch_center coordinates back to normal
patch_center = np.flipud(patch_center)
if 'voxels' in original_blob:
voxels = original_blob['voxels']
blob['voxels'] = voxels[np.all(np.logical_and(
voxels >= patch_center - patch_size / 2.0,
voxels < patch_center + patch_size / 2.0), axis=1)]
blob['voxels'] = blob['voxels'] - (patch_center - patch_size / 2.0)
blob['entries'] = original_blob['entries']
# Crops for small UResNet
if self.cfg.NET == 'small_uresnet':
blob['crops'], blob['crops_labels'] = crop_util(
blob['gt_pixels'][:, :-1],
self.cfg.CROP_SIZE, blob['data'])
# FIXME FIXME FIXME
# Make sure there is at least one ground truth pixel in the patch (for training)
if self.cfg.NET not in ['ppn', 'ppn_ext', 'full'] or len(blob['gt_pixels']) > 0:
batch_blobs.append(blob)
return batch_blobs, patch_centers, patch_sizes
def compute_overlap(self, coords, patch_centers, sizes=None):
"""
Compute overlap dict: dict[x] gives the number of voxels which belong
to x patches.
"""
if sizes is None:
sizes = self.d/2.0
overlap = []
for voxel in coords:
overlap.append(np.sum(np.all(np.logical_and(
patch_centers-sizes <= voxel,
patch_centers + sizes >= voxel
), axis=1)))
return dict(zip(*np.unique(overlap, return_counts=True)))
def add_gt_pixels(self, original_blob, blob, patch_center, patch_size):
"""
Add artificial pixels after cropping
"""
# Case 1: crop boundaries is intersecting with data
nonzero_idx = np.array(np.where(blob['data'][0, ..., 0] > 0.0)).T # N x 3
border_idx = nonzero_idx[np.any(np.logical_or(nonzero_idx == 0, nonzero_idx == self.cfg.IMAGE_SIZE - 1), axis=1)]
# Case 2: crop is partially outside of original data (thus padded)
# if patch_center is within patch_size of boundaries of original blob
# boundary intesecting with data
padded_idx = nonzero_idx[np.any(np.logical_or(nonzero_idx + patch_center - patch_size / 2.0 >= self.cfg.IMAGE_SIZE - 2, nonzero_idx + patch_center - patch_size / 2.0 <= 1), axis=1)]
# dbscan on all found voxels from case 1 and 2
coords = np.concatenate([border_idx, padded_idx], axis=0)
artificial_gt_pixels = []
if coords.shape[0]:
db = DBSCAN(eps=10, min_samples=3).fit_predict(coords)
for v in np.unique(db):
cluster = coords[db == v]
artificial_gt_pixels.append(cluster[np.argmax(blob['data'][0, ..., 0][cluster.T[0], cluster.T[1], cluster.T[2]]), :])
artificial_gt_pixels = np.concatenate([artificial_gt_pixels, np.ones((len(artificial_gt_pixels), 1))], axis=1)
return np.array(artificial_gt_pixels)
def reconcile(self, batch_results, patch_centers, patch_sizes):
"""
Reconcile slices result together
using batch_results, batch_blobs, patch_centers and patch_sizes
"""
final_results = {}
if len(batch_results) == 0: # Empty batch
return final_results
# UResNet predictions
if 'predictions' and 'scores' and 'softmax' in batch_results[0]:
final_voxels = np.array([], dtype=np.int32).reshape(0, 3) # Shape N_voxels x dim
final_scores = np.array([], dtype=np.float32).reshape(0, self.cfg.NUM_CLASSES) # Shape N_voxels x num_classes
final_counts = np.array([], dtype=np.int32).reshape(0,) # Shape N_voxels x 1
for i, result in enumerate(batch_results):
# Extract voxel and voxel values
# Shape N_voxels x dim
v, values = extract_voxels(result['predictions'])
# Extract corresponding softmax scores
# Shape N_voxels x num_classes
scores = result['softmax'][v[:, 0], v[:, 1], v[:, 2], :]
# Restore original blob coordinates
v = (v + np.flipud(patch_centers[i]) - patch_sizes[i] / 2.0).astype(np.int64)
v = np.clip(v, 0, self.cfg.IMAGE_SIZE-1)
# indices are indices of the *first* occurrences of the unique values
# hence for doublons they are indices in final_voxels
# We assume the only overlap that can occur is between
# final_voxels and v, not inside these arrays themselves
n = final_voxels.shape[0]
final_voxels, indices, counts = np.unique(np.concatenate([final_voxels, v], axis=0), axis=0, return_index=True, return_counts=True)
final_scores = np.concatenate([final_scores, scores], axis=0)[indices]
lower_indices = indices[indices < n]
upper_indices = indices[indices >= n]
final_counts[lower_indices] += counts[lower_indices] - 1
final_counts = np.concatenate([final_counts, np.ones((upper_indices.shape[0],))], axis=0)
final_scores = final_scores / final_counts[:, np.newaxis] # Compute average
final_predictions = np.argmax(final_scores, axis=1)
final_results['predictions'] = np.zeros((self.cfg.IMAGE_SIZE,) * 3)
final_results['predictions'][final_voxels.T[0], final_voxels.T[1], final_voxels.T[2]] = final_predictions
final_results['scores'] = np.zeros((self.cfg.IMAGE_SIZE,) * 3)
final_results['scores'][final_voxels.T[0], final_voxels.T[1], final_voxels.T[2]] = final_scores[np.arange(final_scores.shape[0]), final_predictions]
final_results['softmax'] = np.zeros((self.cfg.IMAGE_SIZE,) * 3 + (self.cfg.NUM_CLASSES,))
final_results['softmax'][final_voxels.T[0], final_voxels.T[1], final_voxels.T[2], :] = final_scores
final_results['predictions'] = final_results['predictions'][np.newaxis, ...]
# PPN
if 'im_proposals' and 'im_scores' and 'im_labels' and 'rois' in batch_results[0]:
# print(batch_results[0]['im_proposals'].shape, batch_results[0]['im_scores'].shape, batch_results[0]['im_labels'].shape, batch_results[0]['rois'].shape)
final_im_proposals = np.array([], dtype=np.float32).reshape(0, 3)
final_im_scores = np.array([], dtype=np.float32).reshape(0,)
final_im_labels = np.array([], dtype=np.int32).reshape(0,)
final_rois = np.array([], dtype=np.float32).reshape(0, 3)
for i, result in enumerate(batch_results):
im_proposals = result['im_proposals'] + np.flipud(patch_centers[i]) - patch_sizes[i] / 2.0
im_proposals = np.clip(im_proposals, 0, self.cfg.IMAGE_SIZE-1)
# print(final_im_proposals, im_proposals)
final_im_proposals = np.concatenate([final_im_proposals, im_proposals], axis=0)
final_im_scores = np.concatenate([final_im_scores, result['im_scores']], axis=0)
final_im_labels = np.concatenate([final_im_labels, result['im_labels']], axis=0)
rois = result['rois'] + (np.flipud(patch_centers[i]) - patch_sizes[i] / 2.0) / (self.cfg.dim1 * self.cfg.dim2)
rois = np.clip(rois, 0, self.cfg.IMAGE_SIZE-1)
final_rois = np.concatenate([final_rois, rois], axis=0)
final_results['im_proposals'] = np.array(final_im_proposals)
final_results['im_scores'] = | np.array(final_im_scores) | numpy.array |
import pickle as pkl
from collections import Counter
import numpy as np
import nltk
class DailyDialogCorpus(object):
def __init__(self, corpus_path="data/dailydialog/dailydialog_split.pkl",
max_vocab_cnt=30000, word2vec=True, word2vec_dim=None):
self.word_vec = word2vec
self.word2vec_dim = word2vec_dim
self.word2vec = None
data = pkl.load(open(corpus_path, "rb"))
self.train_data = data["train"]
self.valid_data = data["valid"]
self.test_data = data["test"]
print("DailyDialog Statistics: ")
print("train data size: %d" % len(self.train_data))
print("valid data size: %d" % len(self.valid_data))
print("test data size: %d" % len(self.test_data))
print("\n")
# DailyDialog Statistics:
# train data size: 10117
# valid data size: 1500
# test data size: 1500
self.train_corpus = self.process(self.train_data)
self.valid_corpus = self.process(self.valid_data)
self.test_corpus = self.process(self.test_data)
print(" [*] Building word vocabulary.")
self.build_vocab(max_vocab_cnt)
print(" [*] Loading word2vec.")
self.load_word2vec()
def process(self, data):
new_meta = []
new_dialog = []
all_lenes = []
new_utts = []
for obj in data:
topic = obj["topic"]
dial = obj["utts"]
lower_utts = [
(
item["floor"],
# ["<s>"] + item["text"].lower().strip().split(" ") + ["</s>"],
["<s>"] + nltk.WordPunctTokenizer().tokenize(item["text"].lower().strip()) + ["</s>"],
(item["act"], item["emot"])
) for item in dial]
# first
all_lenes.extend([len(u) for c, u, f in lower_utts])
# second
new_utts.extend([utt for floor, utt, feat in lower_utts])
# third
dialog = [(utt, floor, feat) for floor, utt, feat in lower_utts]
new_dialog.append(dialog)
# fourth
meta = (topic,)
new_meta.append(meta)
print("max_utt_len %d, min_utt_len %d, mean_utt_len %.4f" % \
(np.max(all_lenes),np.min(all_lenes), float(np.mean(all_lenes))))
# Max utt len 298, Min utt len 3, Mean utt len 16.54
# Max utt len 156, Min utt len 3, Mean utt len 16.83
# Max utt len 232, Min utt len 3, Mean utt len 16.80
return {"dialog": new_dialog, "meta": new_meta, "utts": new_utts}
def build_vocab(self, max_vocab_cnt):
all_words = []
for tokens in self.train_corpus["utts"]:
all_words.extend(tokens)
vocab_count = Counter(all_words).most_common()
raw_vocab_size = len(vocab_count)
discard_wc = np.sum([c for t, c, in vocab_count[max_vocab_cnt:]])
vocab_count = vocab_count[0:max_vocab_cnt]
self.vocab = ["<pad>", "<unk>"] + [t for t, cnt in vocab_count] # list
self.rev_vocab = self.word2idx = {word:idx for idx, word in enumerate(self.vocab)} # dict
self.idx2word = {idx:word for idx, word in enumerate(self.vocab)} # dict
self.pad_id = self.word2idx["<pad>"]
self.unk_id = self.word2idx["<unk>"]
self.sos_id = self.word2idx["<s>"]
self.eos_id = self.word2idx["</s>"]
self.vocab_size = len(self.vocab)
print("raw_vocab_size %d, actual_vocab_size %d, at cut_off frequent %d OOV rate %f"
% (raw_vocab_size, self.vocab_size,
vocab_count[-1][1],
float(discard_wc) / len(all_words)))
print("<pad> index %d" % self.pad_id)
print("<unk> index %d" % self.unk_id)
print("<s> index %d" % self.sos_id)
print("</s> index %d" % self.eos_id)
print("\n")
print("Building topic vocabulary...")
all_topics = []
for topic, in self.train_corpus["meta"]:
all_topics.append(topic)
self.topic_vocab = [t for t, cnt in Counter(all_topics).most_common()]
self.rev_topic_vocab = {t: idx for idx, t in enumerate(self.topic_vocab)}
print("number of topics: %d" % len(self.topic_vocab))
print(self.topic_vocab)
print("\n")
all_dialog_acts = []
all_emots = []
for dialog in self.train_corpus["dialog"]:
all_dialog_acts.extend([feat[0] for floor, utt, feat in dialog if feat is not None])
all_emots.extend([feat[1] for floor, utt, feat in dialog if feat is not None])
print("Building act vocabulary...")
self.dialog_act_vocab = [t for t, cnt in Counter(all_dialog_acts).most_common()]
self.rev_dialog_act_vocab = {t: idx for idx, t in enumerate(self.dialog_act_vocab)}
print("number of acts: %d" % len(self.dialog_act_vocab))
print(self.dialog_act_vocab)
print("\n")
print("Building emotion vocabulary...")
self.dialog_emot_vocab = [t for t, cnt in Counter(all_emots).most_common()]
self.rev_dialog_emot_vocab = {t: idx for idx, t in enumerate(self.dialog_emot_vocab)}
print("number of emots: %d" % len(self.dialog_emot_vocab))
print(self.dialog_emot_vocab)
print("\n")
def load_word2vec(self):
if self.word_vec is False:
print(" [*] No word2vec provided.")
return None
with open("data/glove.twitter.27B.200d.txt", "r") as f:
lines = f.readlines()
raw_word2vec = {}
for l in lines:
w, vec = l.split(" ", 1)
raw_word2vec[w] = vec
self.word2vec = None
oov_cnt = 0
for word in self.vocab:
str_vec = raw_word2vec.get(word, None)
if str_vec is None:
oov_cnt += 1
vec = np.random.randn(self.word2vec_dim) * 0.1
else:
vec = np.fromstring(str_vec, sep=" ")
vec = np.expand_dims(vec, axis=0)
self.word2vec = | np.concatenate((self.word2vec, vec),0) | numpy.concatenate |
import pytest
from SciDataTool import DataTime, Data1D, DataLinspace, DataPattern
import numpy as np
from numpy.testing import assert_array_almost_equal
@pytest.mark.validation
def test_period_linspace():
time = np.linspace(0, 10, 10, endpoint=False)
Time = DataLinspace(
name="time",
unit="s",
initial=0,
final=10,
number=10,
include_endpoint=False,
)
Time_periodic = Time.get_axis_periodic(5)
field = np.tile(np.arange(50, 60, 5), 5)
field_periodic = np.arange(50, 60, 5)
Field = DataTime(
name="field",
symbol="X",
axes=[Time_periodic],
values=field_periodic,
)
result = Field.get_along("time")
assert_array_almost_equal(time, result["time"])
assert_array_almost_equal(field, result["X"])
result = Field.get_along("time[smallestperiod]")
assert_array_almost_equal(np.linspace(0, 2, 2, endpoint=False), result["time"])
assert_array_almost_equal(field_periodic, result["X"])
result = Field.get_along("time[oneperiod]")
assert_array_almost_equal(np.linspace(0, 2, 2, endpoint=False), result["time"])
assert_array_almost_equal(field_periodic, result["X"])
@pytest.mark.validation
def test_period_1d():
time = np.linspace(0, 10, 10, endpoint=False)
Time = Data1D(
name="time",
unit="s",
values=time,
)
Time_periodic = Time.get_axis_periodic(5)
field = np.tile(np.arange(50, 60, 5), 5)
field_periodic = np.arange(50, 60, 5)
Field = DataTime(
name="field",
symbol="X",
axes=[Time_periodic],
values=field_periodic,
)
result = Field.get_along("time")
assert_array_almost_equal(time, result["time"])
assert_array_almost_equal(field, result["X"])
result = Field.get_along("time[smallestperiod]")
assert_array_almost_equal(np.linspace(0, 2, 2, endpoint=False), result["time"])
assert_array_almost_equal(field_periodic, result["X"])
result = Field.get_along("time[oneperiod]")
assert_array_almost_equal(np.linspace(0, 2, 2, endpoint=False), result["time"])
assert_array_almost_equal(field_periodic, result["X"])
@pytest.mark.validation
def test_antiperiod_linspace():
time = np.linspace(0, 16, 16, endpoint=False)
Time = DataLinspace(
name="time",
unit="s",
initial=0,
final=16,
number=16,
include_endpoint=False,
)
Time_periodic = Time.get_axis_periodic(4, is_antiperiod=True)
field_periodic = np.arange(50, 70, 5)
field_antisym = np.concatenate((field_periodic, np.negative(field_periodic)))
field = np.tile(field_antisym, 2)
Field = DataTime(
name="field",
symbol="X",
axes=[Time_periodic],
values=field_periodic,
)
result = Field.get_along("time")
assert_array_almost_equal(time, result["time"])
assert_array_almost_equal(field, result["X"])
result = Field.get_along("time[smallestperiod]")
assert_array_almost_equal(np.linspace(0, 4, 4, endpoint=False), result["time"])
assert_array_almost_equal(field_periodic, result["X"])
result = Field.get_along("time[antiperiod]")
assert_array_almost_equal(np.linspace(0, 4, 4, endpoint=False), result["time"])
assert_array_almost_equal(field_periodic, result["X"])
result = Field.get_along("time[oneperiod]")
assert_array_almost_equal(np.linspace(0, 8, 8, endpoint=False), result["time"])
assert_array_almost_equal(field_antisym, result["X"])
@pytest.mark.validation
def test_antiperiod_1d():
time = np.linspace(0, 16, 16, endpoint=False)
Time = Data1D(
name="time",
unit="s",
values=time,
)
Time_periodic = Time.get_axis_periodic(4, is_antiperiod=True)
field_periodic = np.arange(50, 70, 5)
field_antisym = np.concatenate((field_periodic, np.negative(field_periodic)))
field = np.tile(field_antisym, 2)
Field = DataTime(
name="field",
symbol="X",
axes=[Time_periodic],
values=field_periodic,
)
result = Field.get_along("time")
assert_array_almost_equal(time, result["time"])
assert_array_almost_equal(field, result["X"])
result = Field.get_along("time[smallestperiod]")
assert_array_almost_equal(np.linspace(0, 4, 4, endpoint=False), result["time"])
assert_array_almost_equal(field_periodic, result["X"])
result = Field.get_along("time[antiperiod]")
assert_array_almost_equal(np.linspace(0, 4, 4, endpoint=False), result["time"])
assert_array_almost_equal(field_periodic, result["X"])
result = Field.get_along("time[oneperiod]")
assert_array_almost_equal(np.linspace(0, 8, 8, endpoint=False), result["time"])
assert_array_almost_equal(field_antisym, result["X"])
@pytest.mark.validation
def test_period_2d():
time = np.linspace(0, 10, 10, endpoint=False)
Time = DataLinspace(
name="time",
unit="s",
initial=0,
final=10,
number=10,
include_endpoint=False,
)
Time_periodic = Time.get_axis_periodic(5)
angle = np.linspace(0, 2 * np.pi, 16, endpoint=False)
Angle = DataLinspace(
name="angle",
unit="rad",
initial=0,
final=2 * np.pi,
number=16,
include_endpoint=False,
)
Angle_periodic = Angle.get_axis_periodic(4, is_antiperiod=True)
ta, at = np.meshgrid(
Time_periodic.get_values(is_smallestperiod=True),
Angle_periodic.get_values(is_smallestperiod=True),
)
field = np.cos(2 * np.pi * 50 * ta + at)
Field = DataTime(
name="field",
symbol="X",
axes=[Angle_periodic, Time_periodic],
values=field,
)
result = Field.get_along("time", "angle=[0,2*pi]")
assert_array_almost_equal(time, result["time"])
assert_array_almost_equal(angle, result["angle"])
@pytest.mark.validation
def test_pattern():
Slices = DataPattern(
name="slice",
unit="m",
values=np.array([-5, -3, -1, 1, 3]),
values_whole=np.array([-5, -3, -3, -1, -1, 1, 1, 3, 3, 5]),
unique_indices=[0, 2, 4, 6, 8],
rebuild_indices=[0, 0, 1, 1, 2, 2, 3, 3, 4, 4],
)
field = np.array([10, 20, 30, 40, 50])
Field = DataTime(
name="field",
symbol="X",
axes=[Slices],
values=field,
)
assert_array_almost_equal(10, Slices.get_length())
assert_array_almost_equal(5, Slices.get_length(is_pattern=True))
result = Field.get_along("slice")
assert_array_almost_equal(
np.array([-5, -3, -3, -1, -1, 1, 1, 3, 3, 5]), result["slice"]
)
assert_array_almost_equal(
np.array([10, 10, 20, 20, 30, 30, 40, 40, 50, 50]), result["X"]
)
result = Field.get_along("slice[pattern]")
assert_array_almost_equal(np.array([-5, -3, -1, 1, 3]), result["slice"])
assert_array_almost_equal(field, result["X"])
result = Field.get_along(
"slice=axis_data",
axis_data={"slice": np.array([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5])},
)
assert_array_almost_equal(
np.array([10, 10, 15, 20, 25, 30, 35, 40, 45, 50, 50]), result["X"]
)
Slices = DataPattern(
name="slice",
unit="m",
values=np.array([0]),
unique_indices=[0],
rebuild_indices=[0],
)
field = np.array([10])
Field = DataTime(
name="field",
symbol="X",
axes=[Slices],
values=field,
)
result = Field.get_along(
"slice=axis_data", axis_data={"slice": np.array([-2, -1, 0, 1, 2])}
)
assert_array_almost_equal(np.array([10, 10, 10, 10, 10]), result["X"])
Slices = DataPattern(
name="slice",
unit="m",
values=np.array([-5, -3, -1, 1, 3]),
values_whole=np.array([-5, -3, -3, -1, -1, 1, 1, 3, 3, 5]),
unique_indices=[0, 2, 4, 6, 8],
rebuild_indices=[0, 0, 1, 1, 2, 2, 3, 3, 4, 4],
)
field = | np.array([10, 20, 30, 20, 10]) | numpy.array |
import matplotlib.pyplot as plt
import numpy as np
import os
import pandas as pd
import seaborn as sns
from functions.data_handling import convert_timestamp
def gather_data_to_plot(wells, df):
"""
Given a well ID, plot the associated data, pull out treatments.
Pull in dataframe of all the data.
"""
data_to_plot = []
error_to_plot = []
legend = []
for well in wells:
data_to_plot.append(df.loc[well, '600_averaged'])
error_to_plot.append(df.loc[well, '600_std'])
legend.append(df.loc[well, 'cell'])
return data_to_plot, error_to_plot, legend
#return data_to_plot, legend
def quick_plot_all_wells(df, fig_save_path, upper_bound):
wavelengths_used = df.columns.values.tolist()
for wavelength in wavelengths_used:
fig, axs = plt.subplots(8, 12, sharex='col', sharey='row', figsize = (20, 10))
sns.set_style('ticks')
axs = axs.flatten()
fig.subplots_adjust(hspace = .2, wspace=.2)
x = convert_timestamp(list(df[wavelength].iloc[0]))
for i in range(2, 98):
y = list(df[wavelength].iloc[i])
axs[i-2].plot(x, y, color = '#d55e00')
axs[i-2].set_ylim(0, upper_bound)
fig.savefig(os.path.join(fig_save_path, 'plot_all_wells_' + wavelength + '.pdf'),
bbox_inches='tight')
plt.show()
return
def make_individual_plots(time, conditions, condition_names, df_merged, fig_save_path, y_max, xbounds, fig_name_header):
for j in range(len(conditions)):
data_to_plot, error_to_plot, legendName = gather_data_to_plot(conditions[j][0], df_merged)
#data_to_plot, legendName = gather_data_to_plot(conditions[j][0], df_merged)
f = plt.figure(figsize=(20,10))
sns.set_style('ticks')
plt.xlabel("Time (min)")
plt.ylabel("OD_600")
plt.title("")
color_palette = ['#e69f00','#56b4e9', '#009e73', '#f0e442', '#d55e00', '#cc79a7']
c = 0
for data in data_to_plot:
error = error_to_plot[c]
plt.semilogy(time, data, color_palette[c], linewidth = 4, alpha = .8, label = legendName[c])
plt.fill_between(np.array(time), np.array(data)- np.array(error),
np.array(data) + np.array(error), alpha=0.15, facecolor = color_palette[c])
plt.ylim([0,y_max])
plt.xlim(xbounds)
c += 1
plt.legend()
sns.despine()
f.savefig(os.path.join(fig_save_path, fig_name_header + condition_names[j] + '.pdf'),
bbox_inches='tight')
plt.show()
plt.clf()
return
def make_individual_plots_subplot(time, conditions, condition_names, df_merged, fig_save_path, y_max, xbounds, fig_name_header):
fig, axs = plt.subplots(3, 1, sharex='col', sharey='row', figsize = (10, 10))
sns.set_style('ticks')
color_palette = ['#e69f00','#56b4e9', '#009e73', '#f0e442', '#d55e00', '#cc79a7']
for j in range(len(conditions)):
data_to_plot, error_to_plot, legendName = gather_data_to_plot(conditions[j][0], df_merged)
for c in range(0, len(data_to_plot)):
error = error_to_plot[c]
data = data_to_plot[c]
axs[j].semilogy(time, data, color_palette[j], linewidth = 4, alpha = .8, label = legendName[c])
axs[j].fill_between( | np.array(time) | numpy.array |
# Copyright (C) 2020 <NAME>
# All rights reserved.
#
# This file is part of kspclib.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# * 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.
#
# * Neither the name of the kspclib project 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.
from . import _kspclib as ksp
import numpy as np
def get_version():
return tuple(ksp.version())
def get_all_grid_addresses(mesh):
"""Return all single-grid addresses
Parameters
----------
mesh : array_like
Conventional regular mesh for grid sampling.
shape=(3,), dtype='int_'
Returns
-------
grid_address : ndarray
Grid addresses of all grid points corresponding to input mesh.
shape=(all_grid_points, 3), dtype='int_'
"""
grid_address = np.zeros((np.prod(mesh), 3), dtype='int_', order='C')
ksp.all_grid_addresses(grid_address, np.array(mesh, dtype='int_'))
return grid_address
def get_double_grid_address(address, mesh, shift=None):
"""Convert grid address plus shift to double-grid address
address_double = 2 * address + shift, where values are reduced to
be closet to 0, -mesh/2 < address_double <= mesh/2.
Parameters
----------
address : array_like
Grid address.
shape=(3,), dtype='int_'
mesh : array_like
Conventional regular mesh for grid sampling.
shape=(3,), dtype='int_'
shift : array_like, optional
Half grid shift for conventional regular mesh along reciprocal basis
vector directions. 0 and 1 mean no shift and half shift, recpectively.
shape=(3,), dtype='int_'
Returns
-------
address_double : ndarray
Double-grid address.
shape=(3,), dtype='int_'
"""
address_double = np.zeros(3, dtype='int_', order='C')
if shift is None:
_shift = np.zeros(3, dtype='int_', order='C')
else:
_shift = np.array(shift, dtype='int_')
ksp.double_grid_address(address_double,
np.array(address, dtype='int_'),
np.array(mesh, dtype='int_'),
_shift)
return address_double
def get_double_grid_index(address_double, mesh):
"""Return grid point index of a double-grid address
Parameters
----------
address_double : array_like
Double-grid address.
shape=(3,), dtype='int_'
mesh : array_like
Conventional regular mesh for grid sampling.
shape=(3,), dtype='int_'
Returns
-------
grid_index : int
Grid point index.
"""
return ksp.double_grid_index(np.array(address_double, dtype='int_'),
np.array(mesh, dtype='int_'))
def get_thm_relative_grid_addresses(rec_lattice):
"""Return relative grid addresses of 24 tetrahedra
Parameters
----------
rec_lattice : array_like
Reciprocal basis vectors in column vectors.
shape=(3, 3), dtype='double', order='C'
Returns
-------
relative_addresses : ndarray
Grid address shifts corresponding to 24 tetrahedra surrounding
a grid point for conventional regular grid.
shape=(24, 4, 3), dtype='int_', order='C'
"""
relative_addresses = np.zeros((24, 4, 3), dtype='int_', order='C')
ksp.thm_relative_grid_addresses(
relative_addresses,
np.array(rec_lattice, dtype='double', order='C'))
return relative_addresses
def get_thm_integration_weight(omega, tetrahedra_omegas, function='I'):
"""Return tetheradron method integration weight for a grid point
Parameters
----------
omega : float
Energy where integration weight is computed.
tetrahedra_omegas : array_like
Energies of four vertices of 24 tetrahedra. These energies are those
at the grid points as given by ``get_thm_relative_grid_addresses``.
shape=(24, 4), dtype='double', order='C'
function : str, optional
'I' for delta function and 'J' for Heaviside function. Default is 'I'.
Returns
-------
integration_weight : float
Integration weight for a grid point.
"""
iw = ksp.thm_integration_weight(
float(omega),
np.array(tetrahedra_omegas, dtype='double', order='C'),
str(function.upper()))
return iw
def get_snf3x3(A):
"""Return Smith normal form of 3x3 integer matrix
Parameters
----------
A : array_like
Integer transformation matrix from basis vectors of microzone to
those of primitive basis vectors.
shape=(3, 3), dtype='int_', order='C'
returns
-------
snf : dict
D, P, Q of Smith normal form of 3x3 integer matrix.
The dict keys are ``D``, ``D_diag``, ``P``, ``Q``, respectively.
D, P, Q : shape=(3, 3), dtype='int_', order='C'
D_diag : Diagonal elements of D, shape=(3,), dtype='int_', order='C'
"""
D_diag = np.zeros(3, dtype='int_', order='C')
P = np.zeros((3, 3), dtype='int_', order='C')
Q = np.zeros((3, 3), dtype='int_', order='C')
succeeded = ksp.snf3x3(D_diag, P, Q, np.array(A, dtype='int_', order='C'))
D = np.array(np.diag(D_diag), dtype='int_', order='C')
if succeeded:
return {'D_diag': D_diag, 'D': D, 'P': P, 'Q': Q}
else:
return None
def snf_transform_rotations(rotations,
grid_matrix=None,
D=None,
D_diag=None,
Q=None):
"""Transform rotations by SNF of grid generation matrix
Reciprocal rotation matrices of usual reciprocal basis vectors (R) are
transformed to those of reciprocal basis vectors transformed by D and Q
of Smith normal form of grid generation matrix. The formula implemented is
DQ^{-1}RQD^{-1}.
Grid generation matrix has to be compatible with R. Unless satisfied,
exception is raised.
Parameters
----------
D, D_diag, Q : array_like, optional
D or diagonal elemets of D and Q of Smith normal form of grid matrix.
Default is None.
D, Q : shape=(3, 3), dtype='int_', order='C'.
D_diag : shape=(3,), dtype='int_', order='C'.
grid_matrix : array_like, optional
Grid generation matrix. Default is None.
shape=(3, 3), dtype='int_', order='C'
rotations : array_like
Reciprocal rotation matrices of usual reciprocal basis vectors.
shape=(num_rot, 3, 3), dtype='int_', order='C'
returns
-------
transformed_rotations : ndarray
Transformed reciprocal rotation matrices.
shape=(num_rot, 3, 3), dtype='int_', order='C'
"""
if grid_matrix is not None:
snf = get_snf3x3(grid_matrix)
_D_diag = snf['D_diag']
_Q = snf['Q']
elif D_diag is not None and Q is not None:
_D_diag = D_diag
_Q = Q
elif D is not None and Q is not None:
_D_diag = np.diagonal(D)
_Q = Q
else:
msg = "grid_matrix or D and Q unspecified."
raise RuntimeError(msg)
transformed_rots = np.zeros(rotations.shape, dtype='int_', order='C')
is_compatible = ksp.snf_transform_rotations(
transformed_rots,
np.array(rotations, dtype='int_', order='C'),
np.array(_D_diag, dtype='int_', order='C'),
np.array(_Q, dtype='int_', order='C'))
if is_compatible:
return transformed_rots
else:
msg = "Grid generation matrix and rotation matrices are incompatible."
raise RuntimeError(msg)
def get_all_grgrid_addresses(D_diag):
"""Return all grid addresses
(Generalized-regular-grid version)
Parameters
----------
D_diag : array_like
Diagonal elements of D of Smith normal form.
shape=(3,), dtype='int_'
Returns
-------
grgrid_address : ndarray
Genralized-regular-grid addresses of all grid points corresponding
to D_diag.
shape=(all_grid_points, 3), dtype='int_'
"""
grgrid_address = np.zeros((np.prod(D_diag), 3), dtype='int_', order='C')
ksp.all_grgrid_addresses(grgrid_address, np.array(D_diag, dtype='int_'))
return grgrid_address
def get_double_grgrid_address(address, D_diag, PS=None):
"""Convert grid address plus shift to double-grid address
(Generalized-regular-grid version)
address_double = 2 * address + shift, where values are reduced to
be closet to 0, -mesh/2 < address_double <= mesh/2.
Parameters
----------
address : array_like
Grid address.
shape=(3,), dtype='int_'
D_diag : array_like
Diagonal elements of D of Smith normal form.
shape=(3,), dtype='int_'
PS : array_like, optional
Half grid shifts after transformation by P of Smith normal form.
Let half grid shifts along reciprocal basis vector directions be S,
where s_i = 0 or 1, this array corresponds to np.dot(P, S).
shape=(3,), dtype='int_'
Returns
-------
address_double : ndarray
Double-grid address.
shape=(3,), dtype='int_'
"""
address_double = np.zeros(3, dtype='int_', order='C')
if PS is None:
_PS = np.zeros(3, dtype='int_')
else:
_PS = np.array(PS, dtype='int_')
ksp.double_grgrid_address(address_double,
np.array(address, dtype='int_'),
np.array(D_diag, dtype='int_'),
_PS)
return address_double
def get_grgrid_index(address, D_diag):
"""Return grid point index of a single-grid address
(Generalized-regular-grid version)
Parameters
----------
address : array_like
Single-grid address.
shape=(3,), dtype='int_'
D_diag : array_like
Diagonal elements of D of Smith normal form.
shape=(3,), dtype='int_'
Returns
-------
grid_index : int
Grid point index.
"""
return ksp.grgrid_index(np.array(address, dtype='int_'),
np.array(D_diag, dtype='int_'))
def get_double_grgrid_index(address_double, D_diag, PS=None):
"""Return grid point index of a double-grid address
(Generalized-regular-grid version)
Parameters
----------
address_double : array_like
Double-grid address.
shape=(3,), dtype='int_'
D_diag : array_like
Diagonal elements of D of Smith normal form.
shape=(3,), dtype='int_'
PS : array_like, optional
Half grid shifts after transformation by P of Smith normal form.
Let half grid shifts along reciprocal basis vector directions be S,
where s_i = 0 or 1, this array corresponds to np.dot(P, S).
shape=(3,), dtype='int_'
Returns
-------
grid_index : int
Grid point index.
"""
if PS is None:
_PS = | np.zeros(3, dtype='int_') | numpy.zeros |
from collections import defaultdict
import vg
import math as m
import numpy as np
import random
import pandas as pd
np.seterr(divide='ignore', invalid='ignore')
# -------------------------------------------------------------------------------------------------------------
# Target Sequence: [C1P1, C2P2] OR [C1P1, P2C2] OR [P1C1, C2P2] OR [P1C1, P2C2] sorted based on time
# Features: After blurring Energy, we gain our features such as theta_p, theta_e, energies ...
# # Don't forget to blur energy and shuffle family:)
# -------------------------------------------------------------------------------------------------------------
def icos(a):
if a > 1.0:
a = 1.0
elif a < -1.0:
a = -1.
inv_ = m.acos(a)
return m.degrees(inv_)
# -------------------------------------------------------------------------------------------------------------
# ----------------------------- Filter families based on Energy Window ----------------------------------------
# -------------------------------------------------------------------------------------------------------------
def process_family(family):
dict_ = defaultdict(list)
for i, item in enumerate(family):
dict_[item[-8]].append(i) # ID of particle [-8]
for key in dict_:
items = dict_[key] # items = [0, 1] [2, 3] ke 0 ye satre kamele
energy = 0.0
for item in items:
energy += float(family[item][11])
if energy < 421 or energy > 621: # if energy < 421 or energy > 601:
return False
# print(items)
return True
# -------------------------------------------------------------------------------------------------------------
# ---------------------------------------- Calculate Theta_P and Theta_E and Features for ML-------------------
# -------------------------------------------------------------------------------------------------------------
def calculate(family): # col10: time stamp nana
# global non_comp, compton, pe
# random.shuffle(family)
return_pack = {'ID_Flag': [], 'X': [], 'Y': [], 'Z': [],
'theta_p_1': [], 'theta_e_1': [], 'theta_p_2': [], 'theta_e_2': [],
'theta_p_3': [], 'theta_e_3': [], 'theta_p_4': [], 'theta_e_4': [],
'energy_c1': [], 'energy_p1': [], 'energy_c2': [], 'energy_p2': [],
'event1x': [], 'event1y': [], 'event1z': [],
'event2x': [], 'event2y': [], 'event2z': [],
'event3x': [], 'event3y': [], 'event3z': [],
'event4x': [], 'event4y': [], 'event4z': [],
'time1': [], 'time2': [], 'time3': [], 'time4': [],
'DDA1': [], 'DDA2': [], 'DDA3': [], 'DDA4': [],
'target_seq': [],
'rf_counter': 0, 'tf_counter': 0, 'valid_family': False}
# -------------------------------------------------------------------------------------------------------------
# ---------------------------------Check for family validity whether we have 1C2P combination -----------------
# -------------------------------------------------------------------------------------------------------------
if len(family) != 4:
return return_pack
counter_2 = 0
counter_3 = 0
for i in range(len(family)): # count the number of rows for column -8 to be 2 or 3
if family[i][-8] == '2':
counter_2 += 1
elif family[i][-8] == '3':
counter_3 += 1
"""return empty pack if the row is neither Compton nor Photon"""
if family[i][-3] not in ['Compton', 'PhotoElectric']:
return return_pack
if counter_2 != 2 or counter_3 != 2: # Check if family has 2P2C photon IDs
return return_pack
# -------------------------------------------------------------------------------------------------------------
# ----------------------------------Check if all event ids are identical to recognize Random Coincidences -
# -------------------------------------------------------------------------------------------------------------
event_id = []
for row in family:
event_id.append(int(row[1]))
if event_id[1:] == event_id[:-1]:
return_pack['ID_Flag'].append(1)
# return_pack['tf_counter'] += 1
else:
return_pack['ID_Flag'].append(0)
# return_pack['rf_counter'] += 1
""" Blur Energy to find theta_p and theta_e after blurring not from Ground Truth"""
mu1, sigma1 = 0.0, 17.35881104
for i in range(len(family)):
val = float(family[i][11])
val += np.random.normal(mu1, sigma1)
family[i][11] = str(val)
# # -------------------------------------------------------------------------------------------------------------
# # Prepare target sequence: [C1P1, C2P2] OR [C1P1, P2C2] OR [P1C1, C2P2] OR [P1C1, P2C2] sorted by time! Smaller time comes first]
# # -------------------------------------------------------------------------------------------------------------
dict_label = {'time': [], 'panel': [], 'row': []}
for i, row in enumerate(family):
dict_label['time'].append(row[10])
dict_label['panel'].append(row[-8])
dict_label['row'].append(i)
df = pd.DataFrame(dict_label)
df = df.sort_values(by=['time'], ignore_index=False)
first_panel = df['panel'][0]
target_seq = []
target_seq.extend(list(df[df['panel'] == first_panel]['row']))
target_seq.extend(list(df[df['panel'] != first_panel]['row']))
return_pack['target_seq'] = target_seq
# print(target_seq)
# -------------------------------------------------------------------------------------------------------------
# ---------------------------------------- Calculate Theta_P and Theta_E --------------------------------------
# -------------------------------------------------------------------------------------------------------------
perms = [[target_seq[0], target_seq[1], target_seq[2], target_seq[3]],
[target_seq[1], target_seq[0], target_seq[2], target_seq[3]],
[target_seq[0], target_seq[1], target_seq[3], target_seq[2]],
[target_seq[1], target_seq[0], target_seq[3], target_seq[2]]]
# print(perms)
i = target_seq[0] # 0
j = target_seq[1] # 2
k = target_seq[2] # 1
l = target_seq[3] # 3
a_vector_1 = [float(family[i][13]) - float(family[k][13]),
float(family[i][14]) - float(family[k][14]),
float(family[i][15]) - float(family[k][15])]
b_vector_1 = [float(family[j][13]) - float(family[i][13]),
float(family[j][14]) - float(family[i][14]),
float(family[j][15]) - float(family[i][15])]
a_vector_1 = np.array(a_vector_1)
b_vector_1 = np.array(b_vector_1)
theta_p_1 = vg.angle(a_vector_1, b_vector_1)
theta_e_1 = icos(1. - 511. * (1 / (float(family[j][11])) - 1 / (float(family[i][11]) + float(family[j][11]))))
a_vector_2 = [float(family[j][13]) - float(family[k][13]),
float(family[j][14]) - float(family[k][14]),
float(family[j][15]) - float(family[k][15])]
b_vector_2 = [float(family[i][13]) - float(family[j][13]),
float(family[i][14]) - float(family[j][14]),
float(family[i][15]) - float(family[j][15])]
a_vector_2 = np.array(a_vector_2)
b_vector_2 = np.array(b_vector_2)
theta_p_2 = vg.angle(a_vector_2, b_vector_2)
theta_e_2 = icos(1. - 511. * (1 / (float(family[i][11])) - 1 / (float(family[i][11]) + float(family[j][11]))))
a_vector_3 = [float(family[k][13]) - float(family[j][13]),
float(family[k][14]) - float(family[j][14]),
float(family[k][15]) - float(family[j][15])]
b_vector_3 = [float(family[l][13]) - float(family[k][13]),
float(family[l][14]) - float(family[k][14]),
float(family[l][15]) - float(family[k][15])]
a_vector_3 = np.array(a_vector_3)
b_vector_3 = | np.array(b_vector_3) | numpy.array |
import numpy as np
import pandas as pd
from scipy import stats
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
# GET DATA
path = '../../data/ParteI/data_sub.xlsx'
dataFrame = pd.read_excel(path, header=2, sheet_name='trials_available')
headers = dataFrame.columns
sub_index = len(pd.read_excel(path, header=0, sheet_name='trials_available').columns)
# set initial conditions
trials = 5 # for each speed
fields = 6 # (vas, rnd) for each site
subjects = int(sub_index / fields)
print('number of subjects: ', subjects)
# since we are calculating the mean for each subject in all 3 sites
# its necessary to stablish the index of each score position
index = [0, 2]
color = ['b', 'g']
condition = [3, 10, 30, 50, 100, 200]
# fetch_data will read the column for the specific subject at the specific position
# and storage the scores given the current speed
def fetch_data(trials, dataFrame, headers, condition, i, index_vas, index_speed):
s1 = []
for s in range(0, subjects):
for t in range(0, trials * 6):
if dataFrame[headers[(s * fields + index_speed)]][t] == condition[i]:
s1.append(dataFrame[headers[s * fields + index_vas]][t])
if len(s1) == (trials * subjects):
'''
print(condition[i])
print(s1)
print(np.mean(s1))
'''
mean.append(np.mean(s1))
sd.append(np.std(s1))
se.append(stats.sem(s1))
# the next cycle will move across the data and pass the info for each subject to fetch_data
for j in range(0, len(index)):
index_vas = index[j]
index_speed = index_vas + 1
# create storage variables
mean = []
sd = []
se = []
for i in range(0, len(condition)):
fetch_data(trials, dataFrame, headers, condition, i, index_vas, index_speed)
line_x = | np.array(condition) | numpy.array |
import os
import numpy as np
import matplotlib.pyplot as plt
import h5py
import ROOT
from gna.env import env
from gna.ui import basecmd
from mpl_tools.helpers import savefig
class cmd(basecmd):
@classmethod
def initparser(cls, parser, env):
mode = parser.add_mutually_exclusive_group(required=True)
mode.add_argument('--fit-input', type=os.path.abspath,
help='Path to file with covariance matrix produced by minimizer after the fit')
mode.add_argument('--analysis', type=env.parts.analysis,
help='Analysis from which covmatrices would be used')
parser.add_argument('--fit-parameters', action='append', nargs='*', default=[],
help='Keep only covariances for specified parameters from file')
parser.add_argument('--savefig', '-o', '--output', help='Path to save figure')
parser.add_argument('--cmap', help='Use cmap from matplotlib')
parser.add_argument('--show', action='store_true',
help='Show plot of covariance matrix')
parser.add_argument('--dump', help='File to dump covariance matrix')
parser.add_argument('--mask', action='store_true',
help="Mask zeros from covariance matrix")
def init(self):
if self.opts.fit_input:
self.from_fit()
if self.opts.analysis:
self.from_graph()
if self.opts.mask:
self.mask_zeroes()
self.plot_matrices()
def from_fit(self):
with h5py.File(self.opts.fit_input, 'r') as f:
parameters_from_file = f['par_names']
self.covmat = f['cov_matrix'][:]
sigmas = np.diagonal(self.covmat)**0.5
self.cormat = self.covmat/sigmas/sigmas[:,None]
def from_graph(self):
chol_blocks = (np.tril(block.cov.data()) for block in self.opts.analysis)
matrix_stack = [np.matmul(chol, chol.T) for chol in chol_blocks]
self.covmat = self.make_blocked_matrix(matrix_stack)
sdiag = np.diagonal(covmat)**0.5
self.cormat = covmat/sdiag/sdiag[:,None]
def plot_matrices(self):
if self.opts.cmap:
plt.set_cmap(self.opts.cmap)
fig, ax = plt.subplots()
im = ax.matshow(self.covmat)
ax.minorticks_on()
cbar = fig.colorbar(im)
plt.title("Covariance matrix")
savefig(self.opts.savefig, suffix='_cov')
fig, ax = plt.subplots()
im = ax.matshow(self.cormat)
ax.minorticks_on()
cbar = fig.colorbar(im)
plt.title("Correlation matrix")
savefig(self.opts.savefig, suffix='_cor')
if self.opts.dump:
np.savez(self.opts.dump, self.covmat)
if self.opts.show:
plt.show()
def mask_zeroes(self):
self.covmat = np.ma.array(self.covmat, mask=(self.covmat == 0.))
self.cormat = np.ma.array(self.cormat, mask=(self.cormat == 0.))
def make_blocked_matrix(self, matrices):
matrix_stack = []
total_size = sum(mat.shape[0] for mat in matrices)
for idx, matrix in enumerate(matrices):
size_to_left = sum(mat.shape[1] for mat in matrices[:idx])
assert size_to_left is not None
size_to_right = total_size - size_to_left - matrix.shape[1]
layer = [np.zeros((matrix.shape[0], size_to_left)), matrix, np.zeros((matrix.shape[0], size_to_right))]
matrix_stack.append(layer)
return | np.block(matrix_stack) | numpy.block |
import os
import sys
import obspy
import scipy
import pyasdf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.fftpack import next_fast_len
from obspy.signal.filter import bandpass
from seisgo import noise, stacking,utils
import pygmt as gmt
from obspy import UTCDateTime
def plot_eventsequence(cat,figsize=(12,4),ytype='magnitude',figname=None,
yrange=None,save=False,stem=True):
if isinstance(cat,obspy.core.event.catalog.Catalog):
cat=pd.DataFrame(utils.qml2list(cat))
elif isinstance(cat,list):
cat=pd.DataFrame(cat)
#All magnitudes greater than or equal to the limit will be plotted
plt.figure(figsize=figsize)
plt.title(ytype+" vs. time")
plt.xlabel("Date (UTC)")
plt.ylabel(ytype)
if yrange is not None:
ymin,ymax=yrange
if ytype.lower()=="magnitude":
cat2=cat[(cat.magnitude>=yrange[0]) & (cat.magnitude<=yrange[1]) ]
elif ytype.lower()=="depth":
cat2=cat[(cat.depth>=yrange[0]) & (cat.depth<=yrange[1]) ]
else:
cat2=cat
if ytype.lower()=="magnitude":
ymin=np.min(cat2.magnitude)*0.9
ymax=np.max(cat2.magnitude)*1.1
elif ytype.lower()=="depth":
ymin=np.min(cat2.depth)*0.9
ymax=np.max(cat2.depth)*1.1
t=[]
for i in range(len(cat2)):
tTime=obspy.UTCDateTime(cat2.iloc[i]["datetime"])
t.append(tTime.datetime)
if stem:
if ytype.lower()=="magnitude":
markerline, stemlines, baseline=plt.stem(t,cat2.magnitude,linefmt='k-',markerfmt="o",
bottom=ymin)
elif ytype.lower()=="depth":
markerline, stemlines, baseline=plt.stem(t,cat2.depth,linefmt='k-',markerfmt="o",
bottom=ymin)
markerline.set_markerfacecolor('r')
markerline.set_markeredgecolor('r')
else:
if ytype.lower()=="magnitude":
plt.scatter(t,cat2.magnitude,5,'k')
elif ytype.lower()=="depth":
plt.scatter(t,cat2.depth,cat2.magnitude,'k')
#
plt.grid(axis="both")
plt.ylim([ymin,ymax])
if save:
if figname is not None:
plt.savefig(figname)
else:
plt.savefig(ytype+"_vs_time.png")
else:
plt.show()
def plot_stations(lon,lat,region,markersize="c0.2c",title="station map",style="fancy",figname=None,
format='png',distance=None,projection="M5i", xshift="6i",frame="af"):
"""
lon, lat: could be list of vectors contaning multiple sets of stations. The number of sets must be the same
as the length of the marker list.
marker: a list specifying the symbols for each station set.
region: [minlon,maxlon,minlat,maxlat] for map view
"""
nsta=len(lon)
if isinstance(markersize,str):
markersize=[markersize]*nsta
fig = gmt.Figure()
gmt.config(MAP_FRAME_TYPE=style)
for i in range(nsta):
if i==0:
fig.coast(region=region, resolution="f",projection=projection, rivers='rivers',
water="cyan",frame=frame,land="white",
borders=["1/0.5p,gray,2/1p,gray"])
fig.basemap(frame='+t"'+title+'"')
fig.plot(
x=lon[i],
y=lat[i],
style=markersize[i],
color="red",
)
if figname is None:
figname='stationmap.'+format
fig.savefig(figname)
print('plot was saved to: '+figname)
##plot power spectral density
def plot_psd(data,dt,labels=None,xrange=None,cmap='jet',normalize=True,figsize=(13,5),\
save=False,figname=None,tick_inc=None):
"""
Plot the power specctral density of the data array.
=PARAMETERS=
data: 2-D array containing the data. the data to be plotted should be on axis 1 (second dimention)
dt: sampling inverval in time.
labels: row labels of the data, default is None.
cmap: colormap, default is 'jet'
time_format: format to show time marks, default is: '%Y-%m-%dT%H'
normalize: whether normalize the PSD in plotting, default is True
figsize: figure size, default: (13,5)
"""
data=np.array(data)
if data.ndim > 2:
raise ValueError('only plot 1-d arrya or 2d matrix for now. the input data has a dimention of %d'%(data.ndim))
f,psd=utils.psd(data,1/dt)
f=f[1:]
plt.figure(figsize=figsize)
ax=plt.subplot(111)
if data.ndim==2:
nwin=data.shape[0]
if tick_inc is None:
if nwin>10:
tick_inc = int(nwin/5)
else:
tick_inc = 2
psdN=np.ndarray((psd.shape[0],psd.shape[1]-1))
for i in range(psd.shape[0]):
if normalize: psdN[i,:]=psd[i,1:]/np.max(np.abs(psd[i,1:]))
else: psdN[i,:]=psd[i,1:]
plt.imshow(psdN,aspect='auto',extent=[f.min(),f.max(),psdN.shape[0],0],cmap=cmap)
ax.set_yticks(np.arange(0,nwin,step=tick_inc))
if labels is not None: ax.set_yticklabels(labels[0:nwin:tick_inc])
if normalize: plt.colorbar(label='normalized PSD')
else: plt.colorbar(label='PSD')
else:
if normalize: psdN=psd[1:]/np.max(np.abs(psd[1:]))
else: psdN[i,:]=psd[1:]
plt.plot(f,psdN)
if xrange is None:plt.xlim([f[1],f[-1]])
else:
plt.xlim(xrange)
plt.xscale('log')
plt.xlabel('frequency (Hz)')
plt.title('PSD')
if save:
if figname is not None:
plt.savefig(figname)
else:
plt.savefig("PSD.png")
else:
plt.show()
#############################################################################
############### PLOTTING RAW SEISMIC WAVEFORMS ##########################
#############################################################################
'''
Inherited and modified from the plotting functions in the plotting_module of NoisePy (https://github.com/mdenolle/NoisePy).
Credits should be given to the development team for NoisePy (<NAME> and <NAME>).
'''
def plot_waveform(sfile,net,sta,freqmin,freqmax,save=False,figdir=None,format='pdf'):
'''
display the downloaded waveform for station A
PARAMETERS:
-----------------------
sfile: containing all wavefrom data for a time-chunck in ASDF format
net,sta,comp: network, station name and component
freqmin: min frequency to be filtered
freqmax: max frequency to be filtered
USAGE:
-----------------------
plot_waveform('temp.h5','CI','BLC',0.01,0.5)
'''
# open pyasdf file to read
try:
ds = pyasdf.ASDFDataSet(sfile,mode='r')
sta_list = ds.waveforms.list()
except Exception:
print("exit! cannot open %s to read"%sfile);sys.exit()
# check whether station exists
tsta = net+'.'+sta
if tsta not in sta_list:
raise ValueError('no data for %s in %s'%(tsta,sfile))
tcomp = ds.waveforms[tsta].get_waveform_tags()
ncomp = len(tcomp)
if ncomp==0:
print('no data found for the specified net.sta.')
return None
tr = ds.waveforms[tsta][tcomp[0]]
dt = tr[0].stats.delta
npts = tr[0].stats.npts
tt = np.arange(0,npts)*dt
if ncomp == 1:
data = tr[0].data
data = bandpass(data,freqmin,freqmax,int(1/dt),corners=4, zerophase=True)
fig=plt.figure(figsize=(9,3))
plt.plot(tt,data,'k-',linewidth=1)
plt.title('T\u2080:%s %s.%s.%s @%5.3f-%5.2f Hz' % (tr[0].stats.starttime,net,sta,tcomp[0].split('_')[0].upper(),freqmin,freqmax))
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')
plt.tight_layout()
plt.show()
else:
data = np.zeros(shape=(ncomp,npts),dtype=np.float32)
for ii in range(ncomp):
data[ii] = ds.waveforms[tsta][tcomp[ii]][0].data
data[ii] = bandpass(data[ii],freqmin,freqmax,int(1/dt),corners=4, zerophase=True)
fig=plt.figure(figsize=(9,6))
for c in range(ncomp):
if c==0:
plt.subplot(ncomp,1,1)
plt.plot(tt,data[0],'k-',linewidth=1)
plt.title('T\u2080:%s %s.%s @%5.3f-%5.2f Hz' % (tr[0].stats.starttime,net,sta,freqmin,freqmax))
plt.legend([tcomp[0].split('_')[0].upper()],loc='upper left')
plt.xlabel('Time [s]')
else:
plt.subplot(ncomp,1,c+1)
plt.plot(tt,data[c],'k-',linewidth=1)
plt.legend([tcomp[c].split('_')[0].upper()],loc='upper left')
plt.xlabel('Time [s]')
fig.tight_layout()
if save:
if not os.path.isdir(figdir):os.mkdir(figdir)
sfilebase=sfile.split('/')[-1]
outfname = figdir+'/{0:s}_{1:s}.{2:s}'.format(sfilebase.split('.')[0],net,sta)
fig.savefig(outfname+'.'+format, format=format, dpi=300)
plt.close()
else:
fig.show()
#############################################################################
###############PLOTTING XCORR RESULTS AS THE OUTPUT OF SEISGO ##########################
#############################################################################
def plot_xcorr_substack(sfile,freqmin,freqmax,lag=None,comp='ZZ',
save=True,figdir=None):
'''
display the 2D matrix of the cross-correlation functions for a certain time-chunck.
PARAMETERS:
--------------------------
sfile: cross-correlation functions outputed by SeisGo workflow
freqmin: min frequency to be filtered
freqmax: max frequency to be filtered
lag: time ranges for display
USAGE:
--------------------------
plot_xcorr_substack('temp.h5',0.1,1,100,True,'./')
Note: IMPORTANT!!!! this script only works for cross-correlation with sub-stacks being set to True in S1.
'''
# open data for read
if save:
if figdir==None:print('no path selected! save figures in the default path')
try:
ds = pyasdf.ASDFDataSet(sfile,mode='r')
# extract common variables
spairs = ds.auxiliary_data.list()
path_lists = ds.auxiliary_data[spairs[0]].list()
flag = ds.auxiliary_data[spairs[0]][path_lists[0]].parameters['substack']
dt = ds.auxiliary_data[spairs[0]][path_lists[0]].parameters['dt']
maxlag = ds.auxiliary_data[spairs[0]][path_lists[0]].parameters['maxlag']
except Exception:
print("exit! cannot open %s to read"%sfile);sys.exit()
# only works for cross-correlation with substacks generated
if not flag:
raise ValueError('seems no substacks have been done! not suitable for this plotting function')
# lags for display
if not lag:lag=maxlag
lag0=np.min([1.0*lag,maxlag])
if lag>maxlag:raise ValueError('lag excceds maxlag!')
# t is the time labels for plotting
if lag>=5:
tstep=int(int(lag)/5)
t1=np.arange(-int(lag),0,step=tstep)
t2=np.arange(0,int(lag+0.5*tstep),step=tstep)
t=np.concatenate((t1,t2))
else:
tstep=lag/5
t1=np.arange(-lag,0,step=tstep)
t2=np.arange(0,lag+0.5*tstep,step=tstep)
t=np.concatenate((t1,t2))
indx1 = int((maxlag-lag0)/dt)
indx2 = indx1+2*int(lag0/dt)+1
for spair in spairs:
ttr = spair.split('_')
net1,sta1 = ttr[0].split('.')
net2,sta2 = ttr[1].split('.')
path_lists = ds.auxiliary_data[spair].list()
for ipath in path_lists:
chan1,chan2 = ipath.split('_')
cc_comp=chan1[-1]+chan2[-1]
if cc_comp == comp or comp=='all' or comp=='ALL':
try:
dist = ds.auxiliary_data[spair][ipath].parameters['dist']
ngood= ds.auxiliary_data[spair][ipath].parameters['ngood']
ttime= ds.auxiliary_data[spair][ipath].parameters['time']
except Exception:
print('continue! something wrong with %s %s'%(spair,ipath))
continue
# cc matrix
timestamp = np.empty(ttime.size,dtype='datetime64[s]')
data = ds.auxiliary_data[spair][ipath].data[:,indx1:indx2]
# print(data.shape)
nwin = data.shape[0]
amax = np.zeros(nwin,dtype=np.float32)
if nwin==0 or len(ngood)==1: print('continue! no enough substacks!');continue
tmarks = []
data_normalizd=data
# load cc for each station-pair
for ii in range(nwin):
data[ii] = bandpass(data[ii],freqmin,freqmax,1/dt,corners=4, zerophase=True)
data[ii] = data[ii]-np.mean(data[ii])
amax[ii] = np.max(np.abs(data[ii]))
data_normalizd[ii] = data[ii]/amax[ii]
timestamp[ii] = obspy.UTCDateTime(ttime[ii])
tmarks.append(obspy.UTCDateTime(ttime[ii]).strftime('%Y-%m-%dT%H:%M:%S'))
dstack_mean=np.mean(data,axis=0)
dstack_robust=stacking.robust_stack(data)[0]
# plotting
if nwin>10:
tick_inc = int(nwin/5)
else:
tick_inc = 2
fig = plt.figure(figsize=(10,6))
ax = fig.add_subplot(5,1,(1,3))
ax.matshow(data_normalizd,cmap='seismic',extent=[-lag0,lag0,nwin,0],aspect='auto')
ax.plot((0,0),(nwin,0),'k-')
ax.set_title('%s.%s.%s %s.%s.%s dist:%5.2fkm' % (net1,sta1,chan1,net2,sta2,chan2,dist))
ax.set_xlabel('time [s]')
ax.set_xticks(t)
ax.set_yticks(np.arange(0,nwin,step=tick_inc))
# ax.set_yticklabels(np.arange(0,nwin,step=tick_inc))
ax.set_yticklabels(tmarks[0:nwin:tick_inc])
ax.set_xlim([-lag,lag])
ax.xaxis.set_ticks_position('bottom')
ax1 = fig.add_subplot(5,1,(4,5))
ax1.set_title('stack at %4.2f-%4.2f Hz'%(freqmin,freqmax))
tstack=np.arange(-lag0,lag0+0.5*dt,dt)
if len(tstack)>len(dstack_mean):tstack=tstack[:-1]
ax1.plot(tstack,dstack_mean,'b-',linewidth=1,label='mean')
ax1.plot(tstack,dstack_robust,'r-',linewidth=1,label='robust')
ax1.set_xlabel('time [s]')
ax1.set_xticks(t)
ax1.set_xlim([-lag,lag])
ylim=ax1.get_ylim()
ax1.plot((0,0),ylim,'k-')
ax1.set_ylim(ylim)
ax1.legend(loc='upper right')
ax1.grid()
# ax2 = fig.add_subplot(414)
# ax2.plot(amax/min(amax),'r-')
# ax2.plot(ngood,'b-')
# ax2.set_xlabel('waveform number')
# ax2.set_xticks(np.arange(0,nwin,step=tick_inc))
# ax2.set_xticklabels(tmarks[0:nwin:tick_inc])
# #for tick in ax[2].get_xticklabels():
# # tick.set_rotation(30)
# ax2.legend(['relative amp','ngood'],loc='upper right')
fig.tight_layout()
# save figure or just show
if save:
if figdir==None:figdir = sfile.split('.')[0]
if not os.path.isdir(figdir):os.mkdir(figdir)
outfname = figdir+\
'/{0:s}.{1:s}.{2:s}_{3:s}.{4:s}.{5:s}_{6:s}-{7:s}Hz.png'.format(net1,sta1,\
chan1,net2,\
sta2,chan2,
str(freqmin),str(freqmax))
fig.savefig(outfname, format='png', dpi=400)
print('saved to: '+outfname)
plt.close()
else:
fig.show()
def plot_corrfile(sfile,freqmin,freqmax,lag=None,comp='ZZ',
save=True,figname=None,format='png',figdir=None):
'''
display the 2D matrix of the cross-correlation functions for a certain time-chunck.
PARAMETERS:
--------------------------
sfile: cross-correlation functions outputed by SeisGo workflow
freqmin: min frequency to be filtered
freqmax: max frequency to be filtered
lag: time ranges for display
USAGE:
--------------------------
plot_corrfile('temp.h5',0.1,1,100,True,'./')
'''
# open data for read
if save:
if figdir==None:print('no path selected! save figures in the default path')
corrdict=noise.extract_corrdata(sfile,comp=comp)
clist=list(corrdict.keys())
for c in clist:
corr=corrdict[c]
if comp in list(corr.keys()):
corr[comp].plot(freqmin=freqmin,freqmax=freqmax,lag=lag,save=save,figdir=figdir,
figname=figname,format=format)
def plot_corrdata(corr,freqmin=None,freqmax=None,lag=None,save=False,figdir=None,figsize=(10,8)):
'''
display the 2D matrix of the cross-correlation functions for a certain time-chunck.
PARAMETERS:
--------------------------
corr: : class:`~seisgo.types.CorrData`
CorrData object containing the correlation functions and the metadata.
freqmin: min frequency to be filtered
freqmax: max frequency to be filtered
lag: time ranges for display
USAGE:
--------------------------
plot_corrdata(corr,0.1,1,100,save=True,figdir='./')
'''
# open data for read
if save:
if figdir==None:print('no path selected! save figures in the default path')
netstachan1 = corr.net[0]+'.'+corr.sta[0]+'.'+corr.loc[0]+'.'+corr.chan[0]
netstachan2 = corr.net[1]+'.'+corr.sta[1]+'.'+corr.loc[1]+'.'+corr.chan[1]
dt,maxlag,dist,ngood,ttime,substack = [corr.dt,corr.lag,corr.dist,corr.ngood,corr.time,corr.substack]
# lags for display
if not lag:lag=maxlag
if lag>maxlag:raise ValueError('lag excceds maxlag!')
lag0=np.min([1.0*lag,maxlag])
# t is the time labels for plotting
if lag>=5:
tstep=int(int(lag)/5)
t1=np.arange(-int(lag),0,step=tstep);t2=np.arange(0,int(lag+0.5*tstep),step=tstep)
t=np.concatenate((t1,t2))
else:
tstep=lag/5
t1=np.arange(-lag,0,step=tstep);t2=np.arange(0,lag+0.5*tstep,step=tstep)
t=np.concatenate((t1,t2))
indx1 = int((maxlag-lag0)/dt);indx2 = indx1+2*int(lag0/dt)+1
# cc matrix
if substack:
data = corr.data[:,indx1:indx2]
timestamp = np.empty(ttime.size,dtype='datetime64[s]')
# print(data.shape)
nwin = data.shape[0]
amax = np.zeros(nwin,dtype=np.float32)
if nwin==0 or len(ngood)==1:
print('continue! no enough trace to plot!')
return
tmarks = []
data_normalizd=data
# load cc for each station-pair
for ii in range(nwin):
if freqmin is not None and freqmax is not None:
data[ii] = bandpass(data[ii],freqmin,freqmax,1/dt,corners=4, zerophase=True)
data[ii] = data[ii]-np.mean(data[ii])
amax[ii] = np.max(np.abs(data[ii]))
data_normalizd[ii] = data[ii]/amax[ii]
timestamp[ii] = obspy.UTCDateTime(ttime[ii])
tmarks.append(obspy.UTCDateTime(ttime[ii]).strftime('%Y-%m-%dT%H:%M:%S'))
dstack_mean=np.mean(data,axis=0)
# dstack_robust=stack.robust_stack(data)[0]
# plotting
if nwin>10:
tick_inc = int(nwin/5)
else:
tick_inc = 2
fig = plt.figure(figsize=figsize)
ax = fig.add_subplot(6,1,(1,4))
ax.matshow(data_normalizd,cmap='seismic',extent=[-lag0,lag0,nwin,0],aspect='auto')
ax.plot((0,0),(nwin,0),'k-')
if freqmin is not None and freqmax is not None:
ax.set_title('%s-%s : dist : %5.2f km : %4.2f-%4.2f Hz' % (netstachan1,netstachan2,
dist,freqmin,freqmax))
else:
ax.set_title('%s-%s : dist : %5.2f km : unfiltered' % (netstachan1,netstachan2,dist))
ax.set_xlabel('time [s]')
ax.set_xticks(t)
ax.set_yticks(np.arange(0,nwin,step=tick_inc))
ax.set_yticklabels(tmarks[0:nwin:tick_inc])
ax.set_xlim([-lag,lag])
ax.xaxis.set_ticks_position('bottom')
ax1 = fig.add_subplot(6,1,(5,6))
if freqmin is not None and freqmax is not None:
ax1.set_title('stack at %4.2f-%4.2f Hz'%(freqmin,freqmax))
else:
ax1.set_title('stack: unfiltered')
tstack=np.arange(-lag0,lag0+0.5*dt,dt)
if len(tstack)>len(dstack_mean):tstack=tstack[:-1]
ax1.plot(tstack,dstack_mean,'b-',linewidth=1,label='mean')
# ax1.plot(tstack,dstack_robust,'r-',linewidth=1,label='robust')
ax1.set_xlabel('time [s]')
ax1.set_xticks(t)
ax1.set_xlim([-lag,lag])
ylim=ax1.get_ylim()
ax1.plot((0,0),ylim,'k-')
ax1.set_ylim(ylim)
ax1.legend(loc='upper right')
ax1.grid()
fig.tight_layout()
else: #only one trace available
data = corr.data[indx1:indx2]
# load cc for each station-pair
if freqmin is not None and freqmax is not None:
data = bandpass(data,freqmin,freqmax,1/dt,corners=4, zerophase=True)
data = data-np.mean(data)
amax = np.max(np.abs(data))
data /= amax
timestamp = obspy.UTCDateTime(ttime)
tmarks=obspy.UTCDateTime(ttime).strftime('%Y-%m-%dT%H:%M:%S')
tx=np.arange(-lag0,lag0+0.5*dt,dt)
if len(tx)>len(data):tx=tx[:-1]
plt.figure(figsize=figsize)
ax=plt.gca()
plt.plot(tx,data,'k-',linewidth=1)
if freqmin is not None and freqmax is not None:
plt.title('%s-%s : dist : %5.2f km : %4.2f-%4.2f Hz' % (netstachan1,netstachan2,
dist,freqmin,freqmax))
else:
plt.title('%s-%s : dist : %5.2f km : unfiltered' % (netstachan1,netstachan2,dist))
plt.xlabel('time [s]')
plt.xticks(t)
ylim=ax.get_ylim()
plt.plot((0,0),ylim,'k-')
plt.ylim(ylim)
plt.xlim([-lag,lag])
ax.grid()
# save figure or just show
if save:
if figdir==None:figdir = sfile.split('.')[0]
if not os.path.isdir(figdir):os.mkdir(figdir)
outfname = figdir+\
'/{0:s}_{1:s}_{2:s}-{3:s}Hz.png'.format(netstachan1,netstachan2,
str(freqmin),str(freqmax))
plt.savefig(outfname, format='png', dpi=300)
print('saved to: '+outfname)
plt.close()
else:
plt.show()
'''
Inherited and modified from the plotting functions in the plotting_module of NoisePy (https://github.com/mdenolle/NoisePy).
Credits should be given to the development team for NoisePy (<NAME> and <NAME>).
'''
def plot_xcorr_substack_spect(sfile,freqmin,freqmax,lag=None,save=True,figdir='./'):
'''
display the amplitude spectrum of the cross-correlation functions for a time-chunck.
PARAMETERS:
-----------------------
sfile: cross-correlation functions outputed by S1
freqmin: min frequency to be filtered
freqmax: max frequency to be filtered
lag: time ranges for display
USAGE:
-----------------------
plot_xcorr_substack_spect('temp.h5',0.1,1,200,True,'./')
Note: IMPORTANT!!!! this script only works for the cross-correlation with sub-stacks in S1.
'''
# open data for read
if save:
if figdir==None:print('no path selected! save figures in the default path')
try:
ds = pyasdf.ASDFDataSet(sfile,mode='r')
# extract common variables
spairs = ds.auxiliary_data.list()
path_lists = ds.auxiliary_data[spairs[0]].list()
flag = ds.auxiliary_data[spairs[0]][path_lists[0]].parameters['substack']
dt = ds.auxiliary_data[spairs[0]][path_lists[0]].parameters['dt']
maxlag = ds.auxiliary_data[spairs[0]][path_lists[0]].parameters['maxlag']
except Exception:
print("exit! cannot open %s to read"%sfile);sys.exit()
# only works for cross-correlation with substacks generated
if not flag:
raise ValueError('seems no substacks have been done! not suitable for this plotting function')
# lags for display
if not lag:lag=maxlag
if lag>maxlag:raise ValueError('lag excceds maxlag!')
t = np.arange(-int(lag),int(lag)+dt,step=int(2*int(lag)/4))
indx1 = int((maxlag-lag)/dt)
indx2 = indx1+2*int(lag/dt)+1
nfft = int(next_fast_len(indx2-indx1))
freq = scipy.fftpack.fftfreq(nfft,d=dt)[:nfft//2]
for spair in spairs:
ttr = spair.split('_')
net1,sta1 = ttr[0].split('.')
net2,sta2 = ttr[1].split('.')
for ipath in path_lists:
chan1,chan2 = ipath.split('_')
try:
dist = ds.auxiliary_data[spair][ipath].parameters['dist']
ngood= ds.auxiliary_data[spair][ipath].parameters['ngood']
ttime= ds.auxiliary_data[spair][ipath].parameters['time']
timestamp = np.empty(ttime.size,dtype='datetime64[s]')
except Exception:
print('continue! something wrong with %s %s'%(spair,ipath))
continue
# cc matrix
data = ds.auxiliary_data[spair][ipath].data[:,indx1:indx2]
nwin = data.shape[0]
amax = np.zeros(nwin,dtype=np.float32)
spec = np.zeros(shape=(nwin,nfft//2),dtype=np.complex64)
if nwin==0 or len(ngood)==1: print('continue! no enough substacks!');continue
# load cc for each station-pair
for ii in range(nwin):
spec[ii] = scipy.fftpack.fft(data[ii],nfft,axis=0)[:nfft//2]
spec[ii] /= np.max(np.abs(spec[ii]),axis=0)
data[ii] = bandpass(data[ii],freqmin,freqmax,int(1/dt),corners=4, zerophase=True)
amax[ii] = max(data[ii])
data[ii] /= amax[ii]
timestamp[ii] = obspy.UTCDateTime(ttime[ii])
# plotting
if nwin>10:
tick_inc = int(nwin/5)
else:
tick_inc = 2
fig,ax = plt.subplots(3,sharex=False)
ax[0].matshow(data,cmap='seismic',extent=[-lag,lag,nwin,0],aspect='auto')
ax[0].set_title('%s.%s.%s %s.%s.%s dist:%5.2f km' % (net1,sta1,chan1,net2,sta2,chan2,dist))
ax[0].set_xlabel('time [s]')
ax[0].set_xticks(t)
ax[0].set_yticks(np.arange(0,nwin,step=tick_inc))
ax[0].set_yticklabels(timestamp[0:-1:tick_inc])
ax[0].xaxis.set_ticks_position('bottom')
ax[1].matshow(np.abs(spec),cmap='seismic',extent=[freq[0],freq[-1],nwin,0],aspect='auto')
ax[1].set_xlabel('freq [Hz]')
ax[1].set_ylabel('amplitudes')
ax[1].set_yticks(np.arange(0,nwin,step=tick_inc))
ax[1].xaxis.set_ticks_position('bottom')
ax[2].plot(amax/min(amax),'r-')
ax[2].plot(ngood,'b-')
ax[2].set_xlabel('waveform number')
#ax[1].set_xticks(np.arange(0,nwin,int(nwin/5)))
ax[2].legend(['relative amp','ngood'],loc='upper right')
fig.tight_layout()
# save figure or just show
if save:
if figdir==None:figdir = sfile.split('.')[0]
if not os.path.ifigdir(figdir):os.mkdir(figdir)
outfname = figdir+'/{0:s}.{1:s}.{2:s}_{3:s}.{4:s}.{5:s}.pdf'.format(net1,sta1,chan1,net2,sta2,chan2)
fig.savefig(outfname, format='pdf', dpi=400)
plt.close()
else:
fig.show()
#############################################################################
###############PLOTTING THE POST-STACKING XCORR FUNCTIONS AS OUTPUT OF S2 STEP IN NOISEPY ##########################
#############################################################################
'''
Inherited and modified from the plotting functions in the plotting_module of NoisePy (https://github.com/mdenolle/NoisePy).
Credits should be given to the development team for NoisePy (<NAME> and <NAME>).
'''
def plot_substack_all(sfile,freqmin,freqmax,comp,lag=None,save=False,figdir=None):
'''
display the 2D matrix of the cross-correlation functions stacked for all time windows.
PARAMETERS:
---------------------
sfile: cross-correlation functions outputed by S2
freqmin: min frequency to be filtered
freqmax: max frequency to be filtered
lag: time ranges for display
comp: cross component of the targeted cc functions
USAGE:
----------------------
plot_substack_all('temp.h5',0.1,1,'ZZ',50,True,'./')
'''
# open data for read
if save:
if figdir==None:print('no path selected! save figures in the default path')
paths = comp
try:
ds = pyasdf.ASDFDataSet(sfile,mode='r')
# extract common variables
dtype_lists = ds.auxiliary_data.list()
dt = ds.auxiliary_data[dtype_lists[0]][paths].parameters['dt']
dist = ds.auxiliary_data[dtype_lists[0]][paths].parameters['dist']
maxlag = ds.auxiliary_data[dtype_lists[0]][paths].parameters['maxlag']
except Exception:
print("exit! cannot open %s to read"%sfile);sys.exit()
if len(dtype_lists)==1:
raise ValueError('Abort! seems no substacks have been done')
# lags for display
if not lag:lag=maxlag
if lag>maxlag:raise ValueError('lag excceds maxlag!')
t = np.arange(-int(lag),int(lag)+dt,step=int(2*int(lag)/4))
indx1 = int((maxlag-lag)/dt)
indx2 = indx1+2*int(lag/dt)+1
# other parameters to keep
nwin = len(dtype_lists)-1
data = np.zeros(shape=(nwin,indx2-indx1),dtype=np.float32)
ngood= np.zeros(nwin,dtype=np.int16)
ttime= np.zeros(nwin,dtype=np.int)
timestamp = np.empty(ttime.size,dtype='datetime64[s]')
amax = np.zeros(nwin,dtype=np.float32)
for ii,itype in enumerate(dtype_lists[2:]):
timestamp[ii] = obspy.UTCDateTime(np.float(itype[1:]))
try:
ngood[ii] = ds.auxiliary_data[itype][paths].parameters['ngood']
ttime[ii] = ds.auxiliary_data[itype][paths].parameters['time']
#timestamp[ii] = obspy.UTCDateTime(ttime[ii])
# cc matrix
data[ii] = ds.auxiliary_data[itype][paths].data[indx1:indx2]
data[ii] = bandpass(data[ii],freqmin,freqmax,int(1/dt),corners=4, zerophase=True)
amax[ii] = np.max(data[ii])
data[ii] /= amax[ii]
except Exception as e:
print(e);continue
if len(ngood)==1:
raise ValueError('seems no substacks have been done! not suitable for this plotting function')
# plotting
if nwin>100:
tick_inc = int(nwin/10)
elif nwin>10:
tick_inc = int(nwin/5)
else:
tick_inc = 2
fig,ax = plt.subplots(2,sharex=False)
ax[0].matshow(data,cmap='seismic',extent=[-lag,lag,nwin,0],aspect='auto')
ax[0].set_title('%s dist:%5.2f km filtered at %4.2f-%4.2fHz' % (sfile.split('/')[-1],dist,freqmin,freqmax))
ax[0].set_xlabel('time [s]')
ax[0].set_ylabel('wavefroms')
ax[0].set_xticks(t)
ax[0].set_yticks(np.arange(0,nwin,step=tick_inc))
ax[0].set_yticklabels(timestamp[0:nwin:tick_inc])
ax[0].xaxis.set_ticks_position('bottom')
ax[1].plot(amax/max(amax),'r-')
ax[1].plot(ngood,'b-')
ax[1].set_xlabel('waveform number')
ax[1].set_xticks(np.arange(0,nwin,nwin//5))
ax[1].legend(['relative amp','ngood'],loc='upper right')
# save figure or just show
if save:
if figdir==None:figdir = sfile.split('.')[0]
if not os.path.ifigdir(figdir):os.mkdir(figdir)
outfname = figdir+'/{0:s}_{1:4.2f}_{2:4.2f}Hz.pdf'.format(sfile.split('/')[-1],freqmin,freqmax)
fig.savefig(outfname, format='pdf', dpi=400)
plt.close()
else:
fig.show()
'''
Inherited and modified from the plotting functions in the plotting_module of NoisePy (https://github.com/mdenolle/NoisePy).
Credits should be given to the development team for NoisePy (<NAME> and <NAME>).
'''
def plot_substack_all_spect(sfile,freqmin,freqmax,comp,lag=None,save=False,figdir=None):
'''
display the amplitude spectrum of the cross-correlation functions stacked for all time windows.
PARAMETERS:
-----------------------
sfile: cross-correlation functions outputed by S2
freqmin: min frequency to be filtered
freqmax: max frequency to be filtered
lag: time ranges for display
comp: cross component of the targeted cc functions
USAGE:
-----------------------
plot_substack_all('temp.h5',0.1,1,'ZZ',50,True,'./')
'''
# open data for read
if save:
if figdir==None:print('no path selected! save figures in the default path')
paths = comp
try:
ds = pyasdf.ASDFDataSet(sfile,mode='r')
# extract common variables
dtype_lists = ds.auxiliary_data.list()
dt = ds.auxiliary_data[dtype_lists[0]][paths].parameters['dt']
dist = ds.auxiliary_data[dtype_lists[0]][paths].parameters['dist']
maxlag = ds.auxiliary_data[dtype_lists[0]][paths].parameters['maxlag']
except Exception:
print("exit! cannot open %s to read"%sfile);sys.exit()
if len(dtype_lists)==1:
raise ValueError('Abort! seems no substacks have been done')
# lags for display
if not lag:lag=maxlag
if lag>maxlag:raise ValueError('lag excceds maxlag!')
t = np.arange(-int(lag),int(lag)+dt,step=int(2*int(lag)/4))
indx1 = int((maxlag-lag)/dt)
indx2 = indx1+2*int(lag/dt)+1
nfft = int(next_fast_len(indx2-indx1))
freq = scipy.fftpack.fftfreq(nfft,d=dt)[:nfft//2]
# other parameters to keep
nwin = len(dtype_lists)-1
data = np.zeros(shape=(nwin,indx2-indx1),dtype=np.float32)
spec = np.zeros(shape=(nwin,nfft//2),dtype=np.complex64)
ngood= np.zeros(nwin,dtype=np.int16)
ttime= np.zeros(nwin,dtype=np.int)
timestamp = np.empty(ttime.size,dtype='datetime64[s]')
amax = np.zeros(nwin,dtype=np.float32)
for ii,itype in enumerate(dtype_lists[1:]):
timestamp[ii] = obspy.UTCDateTime(np.float(itype[1:]))
try:
ngood[ii] = ds.auxiliary_data[itype][paths].parameters['ngood']
ttime[ii] = ds.auxiliary_data[itype][paths].parameters['time']
#timestamp[ii] = obspy.UTCDateTime(ttime[ii])
# cc matrix
tdata = ds.auxiliary_data[itype][paths].data[indx1:indx2]
spec[ii] = scipy.fftpack.fft(tdata,nfft,axis=0)[:nfft//2]
spec[ii] /= np.max(np.abs(spec[ii]))
data[ii] = bandpass(tdata,freqmin,freqmax,int(1/dt),corners=4, zerophase=True)
amax[ii] = np.max(data[ii])
data[ii] /= amax[ii]
except Exception as e:
print(e);continue
if len(ngood)==1:
raise ValueError('seems no substacks have been done! not suitable for this plotting function')
# plotting
tick_inc = 50
fig,ax = plt.subplots(3,sharex=False)
ax[0].matshow(data,cmap='seismic',extent=[-lag,lag,nwin,0],aspect='auto')
ax[0].set_title('%s dist:%5.2f km' % (sfile.split('/')[-1],dist))
ax[0].set_xlabel('time [s]')
ax[0].set_ylabel('wavefroms')
ax[0].set_xticks(t)
ax[0].set_yticks(np.arange(0,nwin,step=tick_inc))
ax[0].set_yticklabels(timestamp[0:nwin:tick_inc])
ax[0].xaxis.set_ticks_position('bottom')
ax[1].matshow(np.abs(spec),cmap='seismic',extent=[freq[0],freq[-1],nwin,0],aspect='auto')
ax[1].set_xlabel('freq [Hz]')
ax[1].set_ylabel('amplitudes')
ax[1].set_yticks(np.arange(0,nwin,step=tick_inc))
ax[1].set_yticklabels(timestamp[0:nwin:tick_inc])
ax[1].xaxis.set_ticks_position('bottom')
ax[2].plot(amax/max(amax),'r-')
ax[2].plot(ngood,'b-')
ax[2].set_xlabel('waveform number')
ax[2].set_xticks(np.arange(0,nwin,nwin//15))
ax[2].legend(['relative amp','ngood'],loc='upper right')
# save figure or just show
if save:
if figdir==None:figdir = sfile.split('.')[0]
if not os.path.ifigdir(figdir):os.mkdir(figdir)
outfname = figdir+'/{0:s}.pdf'.format(sfile.split('/')[-1])
fig.savefig(outfname, format='pdf', dpi=400)
plt.close()
else:
fig.show()
'''
Modified from the plotting functions in the plotting_module of NoisePy (https://github.com/mdenolle/NoisePy).
Credits should be given to the development team for NoisePy (<NAME> and <NAME>).
'''
def plot_xcorr_moveout_heatmap(sfiles,sta,dtype,freq,comp,dist_inc,lag=None,save=False,\
figsize=None,format='png',figdir=None):
'''
display the moveout (2D matrix) of the cross-correlation functions stacked for all time chuncks.
PARAMETERS:
---------------------
sfile: cross-correlation functions outputed by S2
sta: station name as the virtual source.
dtype: datatype either 'Allstack_pws' or 'Allstack_linear'
freqmin: min frequency to be filtered
freqmax: max frequency to be filtered
comp: cross component
dist_inc: distance bins to stack over
lag: lag times for displaying
save: set True to save the figures (in pdf format)
figdir: diresied directory to save the figure (if not provided, save to default dir)
USAGE:
----------------------
plot_xcorr_moveout_heatmap('temp.h5','sta','Allstack_pws',0.1,0.2,1,'ZZ',200,True,'./temp')
'''
# open data for read
if save:
if figdir==None:print('no path selected! save figures in the default path')
if not isinstance(freq[0],list):freq=[freq]
freq=np.array(freq)
figlabels=['(a)','(b)','(c)','(d)','(e)','(f)','(g)','(h)','(i)']
if freq.shape[0]>9:
raise ValueError('freq includes more than 9 (maximum allowed for now) elements!')
elif freq.shape[0]==9:
subplot=[3,3]
figsize0=[14,7.5]
elif freq.shape[0] >=7 and freq.shape[0] <=8:
subplot=[2,4]
figsize0=[18,10]
elif freq.shape[0] >=5 and freq.shape[0] <=6:
subplot=[2,3]
figsize0=[14,7.5]
elif freq.shape[0] ==4:
subplot=[2,2]
figsize0=[10,6]
else:
subplot=[1,freq.shape[0]]
if freq.shape[0]==3:
figsize0=[13,3]
elif freq.shape[0]==2:
figsize0=[8,3]
else:
figsize0=[4,3]
if figsize is None:figsize=figsize0
path = comp
receiver = sta+'.h5'
stack_method = dtype.split('_')[-1]
# extract common variables
try:
ds = pyasdf.ASDFDataSet(sfiles[0],mpi=False,mode='r')
dt = ds.auxiliary_data[dtype][path].parameters['dt']
maxlag= ds.auxiliary_data[dtype][path].parameters['maxlag']
except Exception:
print("exit! cannot open %s to read"%sfiles[0]);sys.exit()
# lags for display
if lag is None:lag=maxlag
if lag>maxlag:raise ValueError('lag excceds maxlag!')
t = np.arange(-int(lag),int(lag)+dt,step=(int(2*int(lag)/4)))
indx1 = int((maxlag-lag)/dt)
indx2 = indx1+2*int(lag/dt)+1
# cc matrix
nwin = len(sfiles)
data0 = np.zeros(shape=(nwin,indx2-indx1),dtype=np.float32)
dist = np.zeros(nwin,dtype=np.float32)
ngood= np.zeros(nwin,dtype=np.int16)
# load cc and parameter matrix
for ii in range(len(sfiles)):
sfile = sfiles[ii]
treceiver = sfile.split('_')[-1]
ds = pyasdf.ASDFDataSet(sfile,mpi=False,mode='r')
try:
# load data to variables
dist[ii] = ds.auxiliary_data[dtype][path].parameters['dist']
ngood[ii]= ds.auxiliary_data[dtype][path].parameters['ngood']
tdata = ds.auxiliary_data[dtype][path].data[indx1:indx2]
if treceiver == receiver: tdata=np.flip(tdata,axis=0)
except Exception:
print("continue! cannot read %s "%sfile);continue
data0[ii] = tdata
ntrace = int(np.round(np.max(dist)+0.51)/dist_inc)
fig=plt.figure(figsize=figsize)
for f in range(len(freq)):
freqmin=freq[f][0]
freqmax=freq[f][1]
data = np.zeros(shape=(nwin,indx2-indx1),dtype=np.float32)
for i2 in range(data0.shape[0]):
data[i2]=bandpass(data0[i2],freqmin,freqmax,1/dt,corners=4, zerophase=True)
# average cc
ndata = np.zeros(shape=(ntrace,indx2-indx1),dtype=np.float32)
ndist = np.zeros(ntrace,dtype=np.float32)
for td in range(ndata.shape[0]):
tindx = np.where((dist>=td*dist_inc)&(dist<(td+1)*dist_inc))[0]
if len(tindx):
ndata[td] = np.mean(data[tindx],axis=0)
ndist[td] = (td+0.5)*dist_inc
# normalize waveforms
indx = np.where(ndist>0)[0]
ndata = ndata[indx]
ndist = ndist[indx]
for ii in range(ndata.shape[0]):
# print(ii,np.max(np.abs(ndata[ii])))
ndata[ii] /= np.max(np.abs(ndata[ii]))
# plotting figures
ax=fig.add_subplot(subplot[0],subplot[1],f+1)
ax.matshow(ndata,cmap='seismic',extent=[-lag,lag,ndist[-1],ndist[0]],aspect='auto')
ax.set_title('%s %s stack %s %5.3f-%5.2f Hz'%(figlabels[f],sta,stack_method,freqmin,freqmax))
ax.set_xlabel('time [s]')
ax.set_ylabel('distance [km]')
ax.set_xticks(t)
ax.xaxis.set_ticks_position('bottom')
#ax.text(np.ones(len(ndist))*(lag-5),dist[ndist],ngood[ndist],fontsize=8)
plt.tight_layout()
# save figure or show
if save:
outfname = figdir+'/moveout_'+sta+'_heatmap_'+str(stack_method)+'_'+str(dist_inc)+'kmbin_'+comp+'.'+format
plt.savefig(outfname, format=format, dpi=300)
plt.close()
else:
plt.show()
#test functions
def plot_xcorr_moveout_wiggle(sfiles,sta,dtype,freq,ccomp=None,scale=1.0,lag=None,\
ylim=None,save=False,figsize=None,figdir=None,format='png',minsnr=None):
'''
display the moveout waveforms of the cross-correlation functions stacked for all time chuncks.
PARAMETERS:
---------------------
sfile: cross-correlation functions outputed by S2
sta: source station name
dtype: datatype either 'Allstack0pws' or 'Allstack0linear'
freqmin: min frequency to be filtered
freqmax: max frequency to be filtered
ccomp: x-correlation component names, could be a string or a list of strings.
scale: plot the waveforms with scaled amplitudes
lag: lag times for displaying
save: set True to save the figures (in pdf format)
figdir: diresied directory to save the figure (if not provided, save to default dir)
minsnr: mimumum SNR as a QC criterion, the SNR is computed as max(abs(trace))/mean(abs(trace)),
without signal and noise windows.
USAGE:
----------------------
plot_xcorr_moveout_wiggle('temp.h5','Allstack0pws',0.1,0.2,'ZZ',200,True,'./temp')
'''
if not isinstance(freq[0],list):freq=[freq]
freq=np.array(freq)
figlabels=['(a)','(b)','(c)','(d)','(e)','(f)','(g)','(h)','(i)']
if freq.shape[0]>9:
raise ValueError('freq includes more than 9 (maximum allowed for now) elements!')
elif freq.shape[0]==9:
subplot=[3,3]
figsize0=[14,7.5]
elif freq.shape[0] >=7 and freq.shape[0] <=8:
subplot=[2,4]
figsize0=[18,10]
elif freq.shape[0] >=5 and freq.shape[0] <=6:
subplot=[2,3]
figsize0=[14,7.5]
elif freq.shape[0] ==4:
subplot=[2,2]
figsize0=[10,6]
else:
subplot=[1,freq.shape[0]]
if freq.shape[0]==3:
figsize0=[13,3]
elif freq.shape[0]==2:
figsize0=[8,3]
else:
figsize0=[4,3]
if figsize is None:figsize=figsize0
#
qc=False
if minsnr is not None:
qc=True
# open data for read
if save:
if figdir==None:print('no path selected! save figures in the default path')
receiver = sta+'.h5'
stack_method = dtype.split('_')[-1]
if isinstance(ccomp,str):ccomp=[ccomp]
# extract common variables
try:
ds = pyasdf.ASDFDataSet(sfiles[0],mpi=False,mode='r')
complist=ds.auxiliary_data[dtype].list()
dt = ds.auxiliary_data[dtype][complist[0]].parameters['dt']
maxlag= ds.auxiliary_data[dtype][complist[0]].parameters['maxlag']
except Exception:
print("exit! cannot open %s to read"%sfiles[0]);sys.exit()
if ccomp is None:ccomp=complist
# lags for display
if lag is None:lag=maxlag
if lag>maxlag:raise ValueError('lag excceds maxlag!')
tt = np.arange(-lag,lag+dt,dt)
indx0= int(maxlag/dt) #zero time index
indx1 = int((maxlag-lag)/dt)
indx2 = indx1+2*int(lag/dt)+1
# load cc and parameter matrix
for ic in range(len(ccomp)):
comp = ccomp[ic]
data0 = np.zeros(shape=(len(sfiles),indx2-indx1),dtype=np.float32)
dist = np.zeros(len(sfiles),dtype=np.float32)
snrneg = np.zeros(len(sfiles),dtype=np.float32)
snrpos = np.zeros(len(sfiles),dtype=np.float32)
iflip = np.zeros(len(sfiles),dtype=np.int16)
for ii in range(len(sfiles)):
sfile = sfiles[ii]
iflip[ii] = 0
treceiver = sfile.split('_')[-1]
if treceiver == receiver:
iflip[ii] = 1
ds = pyasdf.ASDFDataSet(sfile,mpi=False,mode='r')
try:
# load data to variables
dist[ii] = ds.auxiliary_data[dtype][comp].parameters['dist']
ngood= ds.auxiliary_data[dtype][comp].parameters['ngood']
data0[ii] = ds.auxiliary_data[dtype][comp].data[indx1:indx2]
if qc:
#get the pseudo-SNR: maximum absolute amplitude/mean absolute amplitude.
dneg=ds.auxiliary_data[dtype][comp].data[indx1:indx0-1]
dpos=ds.auxiliary_data[dtype][comp].data[indx0+1:indx2]
snrneg[ii]=np.max(np.abs(dneg))/np.mean(np.abs(dneg))
snrpos[ii]=np.max(np.abs(dpos))/np.mean(np.abs(dpos))
# print([snrneg,snrpos])
except Exception as e:
print("continue! error working on %s "%sfile);
print(e)
continue
mdist=np.max(dist)
mindist=np.min(dist)
plt.figure(figsize=figsize)
for f in range(freq.shape[0]):
freqmin=freq[f][0]
freqmax=freq[f][1]
plt.subplot(subplot[0],subplot[1],f+1)
for i2 in range(data0.shape[0]):
tdata = bandpass(data0[i2],freqmin,freqmax,1/dt,corners=4, zerophase=True)
tdata /= np.max(tdata,axis=0)
if ylim is not None:
if dist[i2]>ylim[1] or dist[i2]<ylim[0]:
continue
if qc:
if np.max([snrneg[i2],snrpos[i2]]) < minsnr:
continue
if iflip[i2]:
plt.plot(tt,scale*np.flip(tdata,axis=0)+dist[i2],'k',linewidth=0.8)
else:
plt.plot(tt,scale*tdata+dist[i2],'k',linewidth=0.8)
plt.title('%s %s filtered %5.3f-%5.3f Hz' % (figlabels[f],sta,freqmin,freqmax))
plt.xlabel('time (s)')
plt.ylabel('offset (km)')
plt.xlim([-1.0*lag,lag])
if ylim is None:
ylim=[0.8*mindist,1.1*mdist]
plt.plot([0,0],ylim,'b--',linewidth=1)
plt.ylim(ylim)
font = {'family': 'serif', 'color': 'red', 'weight': 'bold','size': 14}
plt.text(lag*0.75,ylim[0]+0.07*(ylim[1]-ylim[0]),comp,fontdict=font,
bbox=dict(facecolor='white',edgecolor='none',alpha=0.85))
plt.tight_layout()
# save figure or show
if save:
if len(ccomp)>1:
outfname = figdir+'/moveout_'+sta+'_wiggle_'+str(stack_method)+'_'+str(len(ccomp))+\
'ccomp_minsnr'+str(minsnr)+'.'+format
else:
outfname = figdir+'/moveout_'+sta+'_wiggle_'+str(stack_method)+'_'+ccomp[0]+\
'_minsnr'+str(minsnr)+'.'+format
plt.savefig(outfname, format=format, dpi=300)
plt.close()
else:
plt.show()
#get peak amplitudes
def get_xcorr_peakamplitudes(sfiles,sta,dtype,freq,ccomp=['ZR','ZT','ZZ','RR','RT','RZ','TR','TT','TZ'],
scale=1.0,lag=None,ylim=None,save=False,figdir=None,minsnr=None,
velocity=[1.0,5.0]):
'''
display the moveout waveforms of the cross-correlation functions stacked for all time chuncks.
PARAMETERS:
---------------------
sfile: cross-correlation functions outputed by S2
sta: source station name
dtype: datatype either 'Allstack0pws' or 'Allstack0linear'
freq: [freqmin,freqmax] as a filter.
ccomp: xcorr components to extract.
scale: scale of the waveforms in plotting the traces.
lag: lag times for displaying
save: set True to save the figures (in pdf format)
figdir: diresied directory to save the figure (if not provided, save to default dir)
minsnr: SNR cutoff. the SNR is computed with the given velocity range.
velocity: velocity range for the main phase used to estimate the signal windows.
RETURNS:
-----------------------
A dictionary that contains the following keys: source, receivers. Source is a dictionary containing
the 'name', 'location' of the virtual source. Receivers is a dictionary
containing the 'name' keys of an eight element array for the 'longitude', 'latitude', 'elevation' of
each receiver and the 'distance', 'az','baz',peak_amplitude', 'peak_amplitude_time', 'snr' of the each receiver.
USAGE:
----------------------
get_xcorr_peakamplitudes('temp.h5','Allstack0pws',0.1,0.2,'ZZ',200,True,'./temp')
'''
#initialize out dictionary
outdic=dict()
outdic['source']=dict()
outdic['source']['name']=sta
outdic['source']['location']=np.empty((1,3,)) #three-element array of longitude, latitude, and elevation/depth
outdic['cc_comp']=dict()
qc=False
if minsnr is not None:
qc=True
# open data for read
if save:
if figdir==None:print('no path selected! save figures in the default path')
freqmin=freq[0]
freqmax=freq[1]
source = sta
stack_method = dtype.split('_')[-1]
typeofcomp=str(type(ccomp)).split("'")[1]
ccomptemp=[]
if typeofcomp=='str':
ccomptemp.append(ccomp)
ccomp=ccomptemp
# print(ccomp)
#determine subplot parameters if not specified.
if len(ccomp)>9:
raise ValueError('ccomp includes more than 9 (maximum allowed) elements!')
elif len(ccomp)==9:
subplot=[3,3]
figsize=[14,10.5]
elif len(ccomp) >=7 and len(ccomp) <=8:
subplot=[2,4]
figsize=[18,7.5]
elif len(ccomp) >=5 and len(ccomp) <=6:
subplot=[2,3]
figsize=[14,7.5]
elif len(ccomp) ==4:
subplot=[2,2]
figsize=[10,7.5]
else:
subplot=[1,len(ccomp)]
if len(ccomp)==3:
figsize=[13,3]
elif len(ccomp)==2:
figsize=[8,3]
else:
figsize=[4,3]
# extract common variables
try:
ds = pyasdf.ASDFDataSet(sfiles[0],mpi=False,mode='r')
dt = ds.auxiliary_data[dtype][ccomp[0]].parameters['dt']
maxlag= ds.auxiliary_data[dtype][ccomp[0]].parameters['maxlag']
iflip = 0
treceiver_tmp = sfiles[0].split('_')[-1]
treceiver=treceiver_tmp.split('.')[0]+'.'+treceiver_tmp.split('.')[1]
if treceiver == source:
iflip = 1
if iflip:
outdic['source']['location']=[ds.auxiliary_data[dtype][ccomp[0]].parameters['lonR'],
ds.auxiliary_data[dtype][ccomp[0]].parameters['latR'],0.0]
else:
outdic['source']['location']=[ds.auxiliary_data[dtype][ccomp[0]].parameters['lonS'],
ds.auxiliary_data[dtype][ccomp[0]].parameters['latS'],0.0]
except Exception:
print("exit! cannot open %s to read"%sfiles[0]);sys.exit()
# lags for display
if lag is None:lag=maxlag
if lag>maxlag:raise ValueError('lag excceds maxlag!')
tt = np.arange(-int(lag),int(lag)+dt,dt)
indx0= int(maxlag/dt) #zero time index
indx1 = int((maxlag-lag)/dt)
indx2 = indx1+2*int(lag/dt)+1
# load cc and parameter matrix
plt.figure(figsize=figsize)
for ic in range(len(ccomp)):
comp = ccomp[ic]
outdic['cc_comp'][comp]=dict() #keys of the 'receivers' dictionary are the station names, saving an eight-element array
#for 'longitude', 'latitude', 'elevation','distance','az','baz', 'peak_amplitude', 'peak_amplitude_time', 'snr'.
#
plt.subplot(subplot[0],subplot[1],ic+1)
mdist=0
peakamp=np.empty((len(sfiles),2,))
peakamp.fill(np.nan)
peaktt=np.empty((len(sfiles),2,))
peaktt.fill(np.nan)
distall=np.empty((len(sfiles),))
distall.fill(np.nan)
outdict_tmp=dict()
for ii in range(len(sfiles)):
sfile = sfiles[ii]
iflip = 0
treceiver_tmp = sfile.split('_')[-1]
treceiver=treceiver_tmp.split('.')[0]+'.'+treceiver_tmp.split('.')[1]
tsource=sfile.split('_')[0]
if treceiver == source:
iflip = 1
treceiver=tsource
ds = pyasdf.ASDFDataSet(sfile,mpi=False,mode='r')
try:
# load data to variables
dist = ds.auxiliary_data[dtype][comp].parameters['dist']
distall[ii]=dist
ngood= ds.auxiliary_data[dtype][comp].parameters['ngood']
tdata = ds.auxiliary_data[dtype][comp].data[indx1:indx2]
#get key metadata parameters
if iflip:
az=ds.auxiliary_data[dtype][comp].parameters['baz']
baz=ds.auxiliary_data[dtype][comp].parameters['azi']
lonR=ds.auxiliary_data[dtype][comp].parameters['lonS']
latR=ds.auxiliary_data[dtype][comp].parameters['latS']
else:
az=ds.auxiliary_data[dtype][comp].parameters['azi']
baz=ds.auxiliary_data[dtype][comp].parameters['baz']
lonR=ds.auxiliary_data[dtype][comp].parameters['lonR']
latR=ds.auxiliary_data[dtype][comp].parameters['latR']
except Exception as e:
print("continue! error working on %s "%sfile);
print(e)
continue
if ylim is not None:
if dist>ylim[1] or dist<ylim[0]:
continue
elif dist>mdist:
mdist=dist
#get signal window: start and end indices
signal_neg=[indx0-int(dist/velocity[0]/dt)-indx1,indx0-int(dist/velocity[1]/dt)-indx1]
signal_pos=[int(dist/velocity[1]/dt)+indx0-indx1,int(dist/velocity[0]/dt)+indx0-indx1]
tdata = bandpass(tdata,freqmin,freqmax,int(1/dt),corners=4, zerophase=True)
if dist/velocity[0] > lag:
print('Signal window %6.1f is larger than the max lag %6.1f specified by the user' %
(dist/velocity[0],lag))
continue
if iflip:
dtemp=np.flip(tdata,axis=0)
dn=dtemp[signal_neg[0]:signal_neg[1]] #negative data section
dp=dtemp[signal_pos[0]:signal_pos[1]] #positive dta section
if qc:
#get the pseudo-SNR: maximum absolute amplitude/mean absolute amplitude.
snrneg=np.max(np.abs(dn))/np.mean(np.abs(tdata[0:indx0-1-indx1]))
snrpos=np.max(np.abs(dp))/np.mean(np.abs(tdata[indx0+1-indx1:-1]))
if np.nanmax([snrneg,snrpos]) < minsnr:
continue
#get maximum index
maxidx=[np.argmax(np.abs(dn)),np.argmax(np.abs(dp))]
if maxidx[0] >0 and maxidx[0]<len(dn)-1:
peakamp[ii,0]=np.max(np.abs(dn))
peaktt[ii,0]=tt[maxidx[0]+signal_neg[0]]
if maxidx[1] >0 and maxidx[1]<len(dn)-1:
peakamp[ii,1]=np.max(np.abs(dp))
peaktt[ii,1]=tt[maxidx[1]+signal_pos[0]]
#normalize for plotting
plt.plot(tt,dist + scale*dtemp/np.max(dtemp,axis=0),'k',linewidth=0.5)
else:
dn=tdata[signal_neg[0]:signal_neg[1]] #negative data section
dp=tdata[signal_pos[0]:signal_pos[1]] #positive dta section
if qc:
#get the pseudo-SNR: maximum absolute amplitude/mean absolute amplitude.
snrneg=np.max(np.abs(dn))/np.mean(np.abs(tdata[0:indx0-1-indx1]))
snrpos=np.max(np.abs(dp))/np.mean(np.abs(tdata[indx0+1-indx1:-1]))
if np.nanmax([snrneg,snrpos]) < minsnr:
continue
#get maximum index
maxidx=[np.argmax(np.abs(dn)),np.argmax(np.abs(dp))]
if maxidx[0] >0 and maxidx[0]<len(dn)-1:
peakamp[ii,0]=np.max(np.abs(dn))
peaktt[ii,0]=tt[maxidx[0]+signal_neg[0]]
if maxidx[1] >0 and maxidx[1]<len(dn)-1:
peakamp[ii,1]=np.max(np.abs(dp))
peaktt[ii,1]=tt[maxidx[1]+signal_pos[0]]
plt.plot(tt,dist + scale*tdata/np.max(tdata,axis=0),'k',linewidth=0.5)
#save to out dictionary
#initialize the receiver element.
outdic['cc_comp'][comp][treceiver]=dict()
outdic['cc_comp'][comp][treceiver]['location']=[lonR,latR,0.0]
outdic['cc_comp'][comp][treceiver]['az']=az
outdic['cc_comp'][comp][treceiver]['baz']=baz
outdic['cc_comp'][comp][treceiver]['dist']=dist
outdic['cc_comp'][comp][treceiver]['peak_amplitude']=peakamp[ii,:]
outdic['cc_comp'][comp][treceiver]['peak_amplitude_time']=peaktt[ii,:]
#
for jj in range(len(sfiles)):
plt.plot(peaktt[jj,:],[distall[jj],distall[jj]],'.r',markersize=2)
plt.xlim([-1.0*lag,lag])
if ylim is None:
ylim=[0.0,mdist]
plt.plot([0,0],ylim,'b--',linewidth=1)
#plot the bounding lines for signal windows.
plt.plot([0, ylim[1]/velocity[1]],[0, ylim[1]],'c-',linewidth=0.5) #postive lag starting bound
plt.plot([0, ylim[1]/velocity[0]],[0, ylim[1]],'c-',linewidth=0.5) #postive lag ending bound
plt.plot([0, -ylim[1]/velocity[1]],[0, ylim[1]],'c-',linewidth=0.5) #negative lag starting bound
plt.plot([0, -ylim[1]/velocity[0]],[0, ylim[1]],'c-',linewidth=0.5) #negative lag ending bound
plt.ylim(ylim)
font = {'family': 'serif', 'color': 'red', 'weight': 'bold','size': 10}
plt.text(lag*0.75,ylim[0]+0.07*(ylim[1]-ylim[0]),comp,fontdict=font,
bbox=dict(facecolor='white',edgecolor='none',alpha=0.85))
plt.title('%s filtered @%5.3f-%5.3f Hz' % (sta,freqmin,freqmax))
plt.xlabel('time (s)')
plt.ylabel('offset (km)')
plt.tight_layout()
# save figure or show
if save:
outfname = figdir+'/moveout_'+sta+'_wiggle_'+str(stack_method)+'_'+str(freqmin)+'_'+str(freqmax)+'Hz_'+str(len(ccomp))+'ccomp_minsnr'+str(minsnr)+'_peakamp.png'
plt.savefig(outfname, format='png', dpi=300)
plt.close()
else:
plt.show()
return outdic
#####
def plot_xcorr_amplitudes(dict_in,region,fignamebase=None,format='png',distance=None,
projection="M5i", xshift="6i",frame="af"):
"""
This function plots the peak amplitude maps for both negative and positive lags,
for each xcorr component pair. The map views plot amplitudes corrected for geometric
spreading for surface waves. This function calls pygmt package for plotting. It also plots
peak amplitudes v.s. distance, without correcting the amplitudes for geometric spreading.
PARAMETERS:
----------------------------
dict_in: dictionary containing peak amplitude information from one virtual source to all other receivers.
This can be the output of get_xcorr_peakamplitudes().
region: [minlon,maxlon,minlat,maxlat] for map view
DEPENDENCIES:
----------------------------
PyGMT: for plotting map view with geographical projections, which can be specified as arguments.
"""
source=dict_in['source']['name']
lonS,latS,eleS=dict_in['source']['location']
mindatapoints=2 #at least two receivers having data. otherwise, skip.
#
if fignamebase is None:
fignamebase = source
cc_comp=list(dict_in['cc_comp'].keys())
for ic in range(len(cc_comp)):
comp = cc_comp[ic]
receivers=list(dict_in['cc_comp'][comp].keys())
lonR=[]
latR=[]
dist=[]
peakamp_neg=[]
peakamp_pos=[]
peaktt_neg=[]
peaktt_pos=[]
for ir in range(len(receivers)):
receiver=receivers[ir]
dist0=dict_in['cc_comp'][comp][receiver]['dist']
if distance is not None:
if dist0<distance[0] or dist0>distance[1]:
continue
dist.append(dist0)
lonR.append(dict_in['cc_comp'][comp][receiver]['location'][0])
latR.append(dict_in['cc_comp'][comp][receiver]['location'][1])
peakamp_neg.append(np.array(dict_in['cc_comp'][comp][receiver]['peak_amplitude'])[0]*dist0)
peakamp_pos.append(np.array(dict_in['cc_comp'][comp][receiver]['peak_amplitude'])[1]*dist0)
peaktt_neg.append(np.array(dict_in['cc_comp'][comp][receiver]['peak_amplitude_time'])[0])
peaktt_pos.append(np.array(dict_in['cc_comp'][comp][receiver]['peak_amplitude_time'])[1])
if len(peakamp_neg) >= mindatapoints:
#amplitudes map views
panelstring=['(a) negative lag','(b) positive lag']
fig = gmt.Figure()
for d,dat in enumerate([peakamp_neg,peakamp_pos]):
if d>0:
fig.shift_origin(xshift=xshift)
fig.coast(region=region, projection=projection, frame=frame,land="gray",
shorelines=True,borders=["1/1p,black","2/0.5p,white"])
fig.basemap(frame='+t"'+fignamebase.split('/')[-1]+'_'+comp+':'+panelstring[d]+'"')
fig.plot(
x=lonS,
y=latS,
style="a0.5c",
color="black",
)
gmt.makecpt(cmap="viridis", series=[np.min(dat), np.max(dat)])
fig.plot(
x=lonR,
y=latR,
color=dat,
cmap=True,
style="c0.3c",
pen="black",
)
fig.colorbar(frame='af+l"Amplitude"')
figname=fignamebase+'_'+comp+'_peakamp_map.'+format
fig.savefig(figname)
print('plot was saved to: '+figname)
#peak amplitude arrival times
fig = gmt.Figure()
for d,dat in enumerate([peaktt_neg,peaktt_pos]):
if d>0:
fig.shift_origin(xshift=xshift)
if d==0:
dat=np.multiply(dat,-1.0)
fig.coast(region=region, projection=projection, frame=frame,land="gray",
shorelines=True,borders=["1/1p,black","2/0.5p,white"])
fig.basemap(frame='+t"'+fignamebase.split('/')[-1]+'_'+comp+':'+panelstring[d]+'"')
fig.plot(
x=lonS,
y=latS,
style="a0.5c",
color="black",
)
gmt.makecpt(cmap="viridis", series=[np.min(dat), | np.max(dat) | numpy.max |
import unittest
import astropy_healpix as aph
import healvis
import numpy as np
import pytest
from astropy.units import sday, rad
from pyuvsim.analyticbeam import AnalyticBeam
from vis_cpu import HAVE_GPU
from hera_sim.defaults import defaults
from hera_sim import io
from hera_sim import vis
from hera_sim.antpos import linear_array
from hera_sim.visibilities import VisCPU, HealVis
SIMULATORS = (HealVis, VisCPU)
if HAVE_GPU:
class VisGPU(VisCPU):
"""Simple mock class to make testing VisCPU with use_gpu=True easier"""
def __init__(self, *args, **kwargs):
super().__init__(*args, use_gpu=True, **kwargs)
SIMULATORS = SIMULATORS + (VisGPU,)
np.random.seed(0)
NTIMES = 10
BM_PIX = 31
NPIX = 12 * 16 ** 2
NFREQ = 5
@pytest.fixture
def uvdata():
defaults.set("h1c")
return io.empty_uvdata(
Nfreqs=NFREQ,
integration_time=sday.to("s") / NTIMES,
Ntimes=NTIMES,
array_layout={
0: (0, 0, 0),
},
start_time=2456658.5,
conjugation="ant1<ant2",
)
@pytest.fixture
def uvdataJD():
defaults.set("h1c")
return io.empty_uvdata(
Nfreqs=NFREQ,
integration_time=sday.to("s") / NTIMES,
Ntimes=NTIMES,
array_layout={
0: (0, 0, 0),
},
start_time=2456659,
)
def test_healvis_beam(uvdata):
freqs = np.unique(uvdata.freq_array)
# just anything
point_source_pos = np.array([[0, uvdata.telescope_location_lat_lon_alt[0]]])
point_source_flux = np.array([[1.0]] * len(freqs))
hv = HealVis(
uvdata=uvdata,
sky_freqs=np.unique(uvdata.freq_array),
point_source_flux=point_source_flux,
point_source_pos=point_source_pos,
nside=2 ** 4,
)
assert len(hv.beams) == 1
assert isinstance(hv.beams[0], healvis.beam_model.AnalyticBeam)
def test_healvis_beam_obsparams(tmpdir):
# Now try creating with an obsparam file
direc = tmpdir.mkdir("test_healvis_beam")
with open(direc.join("catalog.txt"), "w") as fl:
fl.write(
"""SOURCE_ID RA_J2000 [deg] Dec_J2000 [deg] Flux [Jy] Frequency [Hz]
HERATEST0 68.48535 -28.559917 1 100000000.0
"""
)
with open(direc.join("telescope_config.yml"), "w") as fl:
fl.write(
"""
beam_paths:
0 : 'uniform'
telescope_location: (-30.72152777777791, 21.428305555555557, 1073.0000000093132)
telescope_name: MWA
"""
)
with open(direc.join("layout.csv"), "w") as fl:
fl.write(
"""Name Number BeamID E N U
Tile061 40 0 -34.8010 -41.7365 1.5010
Tile062 41 0 -28.0500 -28.7545 1.5060
Tile063 42 0 -11.3650 -29.5795 1.5160
Tile064 43 0 -9.0610 -20.7885 1.5160
"""
)
with open(direc.join("obsparams.yml"), "w") as fl:
fl.write(
"""
freq:
Nfreqs: 1
channel_width: 80000.0
start_freq: 100000000.0
sources:
catalog: {0}/catalog.txt
telescope:
array_layout: {0}/layout.csv
telescope_config_name: {0}/telescope_config.yml
time:
Ntimes: 1
integration_time: 11.0
start_time: 2458098.38824015
""".format(
direc.strpath
)
)
hv = HealVis(obsparams=direc.join("obsparams.yml").strpath)
beam = hv.beams[0]
print(beam)
print(type(beam))
print(beam.__class__)
assert isinstance(beam, healvis.beam_model.AnalyticBeam)
def test_JD(uvdata, uvdataJD):
freqs = np.unique(uvdata.freq_array)
# put a point source in
point_source_pos = np.array([[0, uvdata.telescope_location_lat_lon_alt[0]]])
point_source_flux = np.array([[1.0]] * len(freqs))
viscpu1 = VisCPU(
uvdata=uvdata,
sky_freqs=np.unique(uvdata.freq_array),
point_source_flux=point_source_flux,
point_source_pos=point_source_pos,
nside=2 ** 4,
).simulate()
viscpu2 = VisCPU(
uvdata=uvdataJD,
sky_freqs=np.unique(uvdataJD.freq_array),
point_source_flux=point_source_flux,
point_source_pos=point_source_pos,
nside=2 ** 4,
).simulate()
assert viscpu1.shape == viscpu2.shape
assert not np.allclose(viscpu1, viscpu2, atol=0.1)
@pytest.fixture
def uvdata2():
defaults.set("h1c")
return io.empty_uvdata(
Nfreqs=NFREQ,
integration_time=sday.to("s") / NTIMES,
Ntimes=NTIMES,
array_layout={0: (0, 0, 0), 1: (1, 1, 0)},
start_time=2456658.5,
conjugation="ant1<ant2",
)
def create_uniform_sky(nbase=4, scale=1, nfreq=NFREQ):
"""Create a uniform sky with total (integrated) flux density of `scale`"""
nside = 2 ** nbase
npix = 12 * nside ** 2
return np.ones((nfreq, npix)) * scale / (4 * np.pi)
@pytest.mark.parametrize("simulator", SIMULATORS)
def test_shapes(uvdata, simulator):
I_sky = create_uniform_sky()
v = simulator(
uvdata=uvdata,
sky_freqs=np.unique(uvdata.freq_array),
sky_intensity=I_sky,
)
assert v.simulate().shape == (uvdata.Nblts, 1, NFREQ, 1)
@pytest.mark.parametrize("precision, cdtype", [(1, np.complex64), (2, complex)])
def test_dtypes(uvdata, precision, cdtype):
I_sky = create_uniform_sky()
sim = VisCPU(
uvdata=uvdata,
sky_freqs=np.unique(uvdata.freq_array),
sky_intensity=I_sky,
precision=precision,
)
v = sim.simulate()
assert v.dtype == cdtype
@pytest.mark.parametrize("simulator", SIMULATORS)
def test_zero_sky(uvdata, simulator):
I_sky = create_uniform_sky(scale=0)
sim = simulator(
uvdata=uvdata, sky_freqs=np.unique(uvdata.freq_array), sky_intensity=I_sky
)
v = sim.simulate()
np.testing.assert_equal(v, 0)
@pytest.mark.parametrize("simulator", SIMULATORS)
def test_autocorr_flat_beam(uvdata, simulator):
I_sky = create_uniform_sky(nbase=6)
sim = simulator(
uvdata=uvdata,
sky_freqs=np.unique(uvdata.freq_array),
sky_intensity=I_sky,
)
v = sim.simulate()
# Account for factor of 2 between Stokes I and 'xx' pol for vis_cpu
if simulator == VisCPU:
v *= 2.0
np.testing.assert_allclose(np.abs(v), np.mean(v), rtol=1e-5)
np.testing.assert_almost_equal(np.abs(v), 0.5, 2)
@pytest.mark.parametrize("simulator", SIMULATORS)
def test_single_source_autocorr(uvdata, simulator):
freqs = np.unique(uvdata.freq_array)
# put a point source in that will go through zenith.
point_source_pos = np.array([[0, uvdata.telescope_location_lat_lon_alt[0]]])
point_source_flux = np.array([[1.0]] * len(freqs))
v = simulator(
uvdata=uvdata,
sky_freqs=np.unique(uvdata.freq_array),
point_source_flux=point_source_flux,
point_source_pos=point_source_pos,
nside=2 ** 4,
).simulate()
# Account for factor of 2 between Stokes I and 'xx' pol for vis_cpu
if simulator == VisCPU:
v *= 2.0
# Make sure the source is over the horizon half the time
# (+/- 1 because of the discreteness of the times)
# 1e-3 on either side to account for float inaccuracies.
assert (
-1e-3 + (NTIMES / 2.0 - 1.0) / NTIMES
<= np.round(np.abs(np.mean(v)), 3)
<= (NTIMES / 2.0 + 1.0) / NTIMES + 1e-3
)
@pytest.mark.parametrize("simulator", SIMULATORS)
def test_single_source_autocorr_past_horizon(uvdata, simulator):
freqs = np.unique(uvdata.freq_array)
# put a point source in that will never be up
point_source_pos = np.array(
[[0, uvdata.telescope_location_lat_lon_alt[0] + 1.1 * np.pi / 2]]
)
point_source_flux = np.array([[1.0]] * len(freqs))
v = simulator(
uvdata=uvdata,
sky_freqs=np.unique(uvdata.freq_array),
point_source_flux=point_source_flux,
point_source_pos=point_source_pos,
nside=2 ** 4,
).simulate()
assert np.abs(np.mean(v)) == 0
def test_viscpu_coordinate_correction(uvdata2):
freqs = np.unique(uvdata2.freq_array)
# put a point source in
point_source_pos = np.array([[0, uvdata2.telescope_location_lat_lon_alt[0]]])
point_source_flux = np.array([[1.0]] * len(freqs))
viscpu = VisCPU(
uvdata=uvdata2,
sky_freqs=freqs,
point_source_flux=point_source_flux,
point_source_pos=point_source_pos,
nside=2 ** 4,
)
# Apply correction
viscpu.correct_point_source_pos(obstime="2018-08-31T04:02:30.11", frame="icrs")
v = viscpu.simulate()
assert np.all(~np.isnan(v))
def align_src_to_healpix(point_source_pos, point_source_flux, nside=2 ** 4):
"""Where the point sources will be placed when converted to healpix model
Parameters
----------
point_source_pos : ndarray
Positions of point sources to be passed to a Simulator.
point_source_flux : ndarray
Corresponding fluxes of point sources at each frequency.
nside : int
Healpix nside parameter.
Returns
-------
new_pos: ndarray
Point sources positioned at their nearest healpix centers.
new_flux: ndarray
Corresponding new flux values.
"""
hmap = np.zeros((len(point_source_flux), aph.nside_to_npix(nside)))
# Get which pixel every point source lies in.
pix = aph.lonlat_to_healpix(
point_source_pos[:, 0] * rad,
point_source_pos[:, 1] * rad,
nside,
)
hmap[:, pix] += point_source_flux / aph.nside_to_pixel_area(nside).value
nside = aph.npix_to_nside(hmap.shape[1])
ra, dec = aph.healpix_to_lonlat(np.arange(len(hmap[0])), nside)
flux = hmap * aph.nside_to_pixel_area(nside).value
return np.array([ra.to("rad").value, dec.to("rad").value]).T, flux
def test_comparison_zenith(uvdata2):
freqs = | np.unique(uvdata2.freq_array) | numpy.unique |
from __future__ import print_function, division
import scipy
#from keras.datasets import mnist
from keras_contrib.layers.normalization import InstanceNormalization
from keras.layers import Input, Dense, Reshape, Flatten, Dropout, Concatenate
from keras.layers import BatchNormalization, Activation, ZeroPadding2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.convolutional import UpSampling2D, Conv2D
from keras.models import Sequential, Model
from keras.optimizers import Adam
from keras import optimizers
from keras import initializers
from keras import backend as K
import datetime
import matplotlib.pyplot as plt
from matplotlib import gridspec
import sys
import os
import numpy as np
from skimage import io
from sklearn.model_selection import train_test_split
import scipy.misc
from scipy.misc import imsave
from skimage import data, img_as_float
from skimage.measure import compare_ssim as ssim
import math
#data process functions
def getConvPath(material, num):
root = os.getcwd() +"/newData/" + material
if "Pt_input_images" == material:
newPath = root +"/Pt_convolution/Pt_convolution_" + str(num) + ".txt"
elif "Pt-Mo5_input_images" == material:
newPath = root +"/Pt-Mo_convolution/Pt_Mo5_convolution_" + str(num) +".txt"
elif "Pt-Mo50_input_images" == material:
newPath = root + "/Pt281-Mo280-convolution/Pt_Mo50_convolution_" + str(int(num)+2) + ".txt"
else: print("Material key not found! Please check your spelling.")
return newPath
def getMultislicePath(material, num):
root = os.getcwd() + "/newData/" + material
if "Pt_input_images" == material:
newPath = root +"/Pt_multislice_16_phonons/Pt_" + str(num) + "_cl160mm_ss.tif"
elif "Pt-Mo5_input_images" == material:
newPath = root +"/Pt-Mo_multislice/pt_mo5_" + str(num) +"_cl160mm_ss.tif"
elif "Pt-Mo50_input_images" == material:
newPath = root + "/Pt281-Mo280-multislice/pt_mo50_" + str(int(num)+2) + "_cl160mm_ss.tif"
else: print("material key not found! Please check your spelling.")
return newPath
def getNumImages(material):
if "Pt_input_images" == material:
num = 20
elif "Pt-Mo5_input_images" == material:
num = 20
elif "Pt-Mo50_input_images" == material:
num = 18
else:
num = 0
return num
def cutImage(image,height,width):
newImage = image[:height,:width]
return newImage
#returns list of images cut to be min height and width of the group
def cutImages(images):
widths = []
heights = []
cutImages = []
for image in images:
widths.append(len(image[0]))
heights.append(len(image))
minWidth = min(widths)
minHeight = min(heights)
for i in range(len(images)):
cutImages.append(cutImage(images[i],minHeight,minWidth))
return cutImages
def padImage(image, desiredHeight, desiredWidth):
leftSpace = int((desiredWidth - image.shape[1])/2)
topSpace = int((desiredHeight - image.shape[0])/2)
base = np.zeros((desiredHeight,desiredWidth))
base[topSpace:image.shape[0]+topSpace,leftSpace:image.shape[1]+leftSpace]=image
return base
#returns list of images with desired heigh and width
def formatImages(images,height,width):
newImages = []
for image in roundToZeroes(images):
if image.shape[0] > height and image.shape[1] > width:
newImages.append(cutImage(image))
elif image.shape[0] <= height and image.shape[1] < width:
newImages.append(padImage(image,height,width))
elif image.shape[0] >= height and image.shape[1] <= width:
newImages.append(padImage(image[:height,:],height,width))
elif image.shape[0] < height and image.shape[1] >= width:
newImages.append(padImage(image[:,:width],height,width))
return newImages
# rounds any negative values in the matrix to zero. Requested by Dane
def roundToZeroes(images):
for image in images:
for i in range(image.shape[0]):
for j in range(image.shape[1]):
if image[i,j] < 0.0:
image[i,j] = 0.0
return images
def cutPadding(image,height,width):
h_dif = len(image) - height
w_dif = len(image[0]) - width
top = h_dif//2
left = w_dif//2
if h_dif % 2 == 1:
bottom = top + 1
else:
bottom = top
if w_dif % 2 == 1:
right = left + 1
else:
right = left
newImage = image[top:len(image)-bottom ,left:len(image[0])-right]
return newImage
def kerasSSIM(y_true, y_pred):#may be wrong
## mean, std, correlation
mu_x = K.mean(y_pred)
mu_y = K.mean(y_true)
sig_x = K.std(y_pred)
sig_y = K.std(y_true)
sig_xy = (sig_x * sig_y)**0.5
ssim = (2 * mu_x * mu_y + C1) * (2 * sig_xy * C2) * 1.0 / ((mu_x ** 2 + mu_y ** 2 + C1) * (sig_x ** 2 + sig_y ** 2 + C2))
return ssim
def mean_squared_error(y_true, y_pred):
return K.mean(K.square(y_pred - y_true), axis=-1)
def customLoss(yTrue,yPred):
# print(backend.shape(yTrue))
# print(backend.shape(yPred))
ssimVal = kerasSSIM(yTrue,yPred)
print(ssimVal)
return alpha * (1-ssimVal) + (1-alpha) * mean_squared_error(yTrue, yPred)
dirArray = ["Pt-Mo5_input_images", "Pt_input_images", "Pt-Mo50_input_images"]
matl = dirArray[1] #specify desired material here
#Parses image data into ndarrays, then slices each array to be the minimum width and height of the group.
#Thus, formattedConvImages and formattedMultiImages will have arrays of all the same size.
convImages = []
multiImages = []
widths = []
heights = []
for d in range (0, 3):
matl = dirArray[d]
for i in range(0,getNumImages(matl)):
convArr = np.loadtxt(getConvPath(matl, i))
multiArr = io.imread(getMultislicePath(matl,i))
#TODO: PLEASE DELETE THIS LINE AFTER DATA PROCESSING
if (len(convArr[0]) <= 256 and len(convArr) <= 256):
widths.append(len(convArr[0]))
heights.append(len(convArr))
convImages.append(convArr)
multiImages.append(multiArr)
minWidth = min(widths)
minHeight = min(heights)
print(minWidth)
print(minHeight)
print(len(convImages))
print(len(multiImages))
print( | np.min(convImages[0]) | numpy.min |
# -*- mode: python; coding: utf-8 -*-
# Copyright (c) 2018 Radio Astronomy Software Group
# Licensed under the 2-clause BSD License
"""Class for reading and writing calibration FITS files."""
import warnings
import numpy as np
from astropy.io import fits
from .uvcal import UVCal
from .. import utils as uvutils
__all__ = ["CALFITS"]
class CALFITS(UVCal):
"""
Defines a calfits-specific class for reading and writing calfits files.
This class should not be interacted with directly, instead use the read_calfits
and write_calfits methods on the UVCal class.
"""
def write_calfits(
self,
filename,
run_check=True,
check_extra=True,
run_check_acceptability=True,
clobber=False,
):
"""
Write the data to a calfits file.
Parameters
----------
filename : str
The calfits file to write to.
run_check : bool
Option to check for the existence and proper shapes of
parameters before writing the file.
check_extra : bool
Option to check optional parameters as well as required ones.
run_check_acceptability : bool
Option to check acceptable range of the values of
parameters before writing the file.
clobber : bool
Option to overwrite the filename if the file already exists.
"""
if run_check:
self.check(
check_extra=check_extra, run_check_acceptability=run_check_acceptability
)
if self.Nfreqs > 1:
freq_spacing = self.freq_array[0, 1:] - self.freq_array[0, :-1]
if not np.isclose(
np.min(freq_spacing),
np.max(freq_spacing),
rtol=self._freq_array.tols[0],
atol=self._freq_array.tols[1],
):
raise ValueError(
"The frequencies are not evenly spaced (probably "
"because of a select operation). The calfits format "
"does not support unevenly spaced frequencies."
)
if | np.isclose(freq_spacing[0], self.channel_width) | numpy.isclose |
#!/usr/bin/env python3
import numpy as np
from ccscp.src.utils.polygonal_obstacles import PolygonalObstacle as PolyObs
def get_ISS_zones():
#### INSIDE polytopes
btms_lft, tops_rgt = [np.zeros(3)] * 6, [np.zeros(3)] * 6
btms_lft[0], tops_rgt[0] = np.array([ 5.9,-0.6, 4.2]), np.array([ 7.7, 0.6, 5.4]) # 3
btms_lft[1], tops_rgt[1] = np.array([10.2, 1.2, 4.2]), np.array([11.6, 2.7, 5.5]) # 4
btms_lft[2], tops_rgt[2] = np.array([ 9.6, 2.7, 3.8]), np.array([11.9, 7.3, 5.9]) # 5
btms_lft[3], tops_rgt[3] = np.array([10.3,-2.7, 4.3]), np.array([11.6,-1.2, 5.4]) # 6
btms_lft[4], tops_rgt[4] = np.array([ 7.7,-1.2, 3.7]), np.array([11.6, 1.2, 6.0]) # 8
btms_lft[5], tops_rgt[5] = np.array([11.6,-0.8, 4.1]), np.array([12.0, 0.8, 5.5]) # 16
keepin_zones = []
for (btm, top) in zip(btms_lft, tops_rgt):
center, width = (top+btm)/2., (top-btm)
keepin_zones.append( PolyObs(center,width) )
#### OUTSIDE
btms_lft, tops_rgt = [ | np.zeros(3) | numpy.zeros |
import torch
import numpy as np
import scipy
from scipy import stats
import pandas as pd
import scanpy
import anndata
# tempo imports
from . import utils
# --- PARAMETER FUNCTIONS TO GET VARIATIONAL AND PRIOR DISTRIBUTIONS ---
# ** mesor **
# variational
def get_mesor_variational_params(adata, init_mesor_scale_val = 0.1):
# ** check if mesor_loc and mesor_scale found in adata.var; otherwise init using prop **
if "mu_loc" in adata.var.columns and "mu_scale" in adata.var.columns:
mesor_loc = np.array(adata.var['mu_loc'])
mesor_scale = np.array(adata.var['mu_scale'])
else:
mesor_loc = np.log(np.array(adata.var['prop']))
mesor_scale = np.array([init_mesor_scale_val] * adata.shape[1])
# ** mesor log scale **
mesor_log_scale = np.log(mesor_scale)
# ** init variational pytorch parameters **
mu_loc = torch.nn.Parameter(torch.Tensor(mesor_loc), requires_grad = True)
mu_log_scale = torch.nn.Parameter(torch.Tensor(mesor_log_scale), requires_grad = True)
return mu_loc, mu_log_scale
# prior
def get_mesor_prior_params(adata, prior_mesor_scale_val = 0.5):
# ** check if mesor_loc and mesor_scale found in adata.var; otherwise init using prop **
if "prior_mu_loc" in adata.var.columns and "prior_mu_scale" in adata.var.columns:
prior_mesor_loc = np.array(adata.var['prior_mu_loc'])
prior_mesor_scale = np.array(adata.var['prior_mu_scale'])
else:
prior_mesor_loc = np.log(np.array(adata.var['prop']))
prior_mesor_scale = np.array([prior_mesor_scale_val] * adata.shape[1])
# ** torch tensors **
prior_mesor_loc = torch.Tensor(prior_mesor_loc)
prior_mesor_scale = torch.Tensor(prior_mesor_scale)
return prior_mesor_loc, prior_mesor_scale
# variational and prior
def get_mesor_variational_and_prior_params(adata, init_mesor_scale_val = 0.1, prior_mesor_scale_val = 0.5):
# ** init variational pytorch parameters **
mu_loc, mu_log_scale = get_mesor_variational_params(adata, init_mesor_scale_val = init_mesor_scale_val)
# ** init prior pytorch distributions **
prior_mesor_loc, prior_mesor_scale = get_mesor_prior_params(adata, prior_mesor_scale_val = prior_mesor_scale_val)
return mu_loc, mu_log_scale, prior_mesor_loc, prior_mesor_scale
# ** amplitude **
# variational
def get_amp_variational_params(adata, max_amp = 1.0 / np.log10(np.e), min_amp = 0.2 / np.log10(np.e), init_amp_loc_val = 0.4 / np.log10(np.e), init_amp_scale_val = 400):
# ** check if A_alpha and A_beta are supplied **
if 'A_alpha' in adata.var.columns and 'A_beta' in adata.var.columns:
amp_log_alpha = np.log(np.array(adata.var['A_alpha']))
amp_log_beta = np.log(np.array(adata.var['A_beta']))
A_alpha = torch.nn.Parameter(torch.Tensor(amp_log_alpha), requires_grad = True)
A_beta = torch.nn.Parameter(torch.Tensor(amp_log_beta), requires_grad = True)
return A_alpha, A_beta
# ** raise exception if amp variational loc is not greater than min **
if not (init_amp_loc_val > min_amp and init_amp_loc_val < max_amp):
raise Exception("Error: init amp loc must be within the (min_amp,max_amp) range -- exclusive.")
# ** compute z value ([0,1] which refers to [min_amp, max_amp]) of init_amp_loc_val **
z_val = float((init_amp_loc_val - min_amp) / (max_amp - min_amp))
# ** init variational params as numpy arrays **
amp_alpha = np.array([1.0] * adata.shape[1]) # unscaled alpha and beta
amp_beta = np.array([(1.0 / z_val) - 1.0] * adata.shape[1]) # beta = (1 - z) / z = (1 / z) - 1
amp_alpha = amp_alpha * init_amp_scale_val # scaled alpha and beta
amp_beta = amp_beta * init_amp_scale_val
# ** convert amp alpha and beta to log values **
amp_log_alpha = np.log(amp_alpha)
amp_log_beta = np.log(amp_beta)
# ** init variational pytorch parameters **
A_log_alpha = torch.nn.Parameter(torch.Tensor(amp_log_alpha), requires_grad = True)
A_log_beta = torch.nn.Parameter(torch.Tensor(amp_log_beta), requires_grad = True)
return A_log_alpha, A_log_beta
# prior
def get_amp_prior_params(adata, prior_amp_alpha_val = 1.0, prior_amp_beta_val = 1.0):
# ** check if A_alpha and A_beta are supplied **
if 'prior_A_alpha' in adata.var.columns and 'prior_A_beta' in adata.var.columns:
prior_amp_alpha = | np.array(adata.var['prior_A_alpha']) | numpy.array |
import numpy as np
from confidenceMapUtil import FDRutil
import argparse, math, os, sys
from argparse import RawTextHelpFormatter
import time
def compute_padding_average(vol, mask):
mask = (mask > 0.5).astype(np.int8)
average_padding_intensity = np.mean(np.ma.masked_array(vol, mask))
return average_padding_intensity
def pad_or_crop_volume(vol, dim_pad=None, pad_value = None, crop_volume=False):
if (dim_pad == None):
return vol
else:
dim_pad = np.round(np.array(dim_pad)).astype('int')
if pad_value == None:
pad_value = 0
if (dim_pad[0] <= vol.shape[0] or dim_pad[1] <= vol.shape[1] or dim_pad[2] <= vol.shape[2]):
crop_volume = True
if crop_volume:
crop_vol = vol[int(vol.shape[0]/2-dim_pad[0]/2):int(vol.shape[0]/2+dim_pad[0]/2+dim_pad[0]%2), :, :]
crop_vol = crop_vol[:, int(vol.shape[1]/2-dim_pad[1]/2):int(vol.shape[1]/2+dim_pad[1]/2+dim_pad[1]%2), :]
crop_vol = crop_vol[:, :, int(vol.shape[2]/2-dim_pad[2]/2):int(vol.shape[2]/2+dim_pad[2]/2+dim_pad[2]%2)]
return crop_vol
else:
pad_vol = np.pad(vol, ((int(dim_pad[0]/2-vol.shape[0]/2), int(dim_pad[0]/2-vol.shape[0]/2+dim_pad[0]%2)), (0,0), (0,0) ), 'constant', constant_values=(pad_value,))
pad_vol = np.pad(pad_vol, ((0,0), (int(dim_pad[1]/2-vol.shape[1]/2), int(dim_pad[1]/2-vol.shape[1]/2+dim_pad[1]%2) ), (0,0)), 'constant', constant_values=(pad_value,))
pad_vol = np.pad(pad_vol, ((0,0), (0,0), (int(dim_pad[2]/2-vol.shape[2]/2), int(dim_pad[2]/2-vol.shape[2]/2+dim_pad[2]%2))), 'constant', constant_values=(pad_value,))
return pad_vol
def check_for_window_bleeding(mask, wn):
masked_xyz_locs, masked_indices, mask_shape = get_xyz_locs_and_indices_after_edge_cropping_and_masking(mask, 0)
zs, ys, xs = masked_xyz_locs.T
nk, nj, ni = mask_shape
if xs.min() < wn / 2 or xs.max() > (ni - wn / 2) or \
ys.min() < wn / 2 or ys.max() > (nj - wn / 2) or \
zs.min() < wn / 2 or zs.max() > (nk - wn / 2):
window_bleed = True
else:
window_bleed = False
return window_bleed
def get_xyz_locs_and_indices_after_edge_cropping_and_masking(mask, wn):
mask = np.copy(mask);
nk, nj, ni = mask.shape;
kk, jj, ii = np.indices((mask.shape));
kk_flat = kk.ravel();
jj_flat = jj.ravel();
ii_flat = ii.ravel();
mask_bin = np.array(mask.ravel(), dtype=np.bool);
indices = np.arange(mask.size);
masked_indices = indices[mask_bin];
cropped_indices = indices[(wn / 2 <= kk_flat) & (kk_flat < (nk - wn / 2)) &
(wn / 2 <= jj_flat) & (jj_flat < (nj - wn / 2)) &
(wn / 2 <= ii_flat) & (ii_flat < (ni - wn / 2))];
cropp_n_mask_ind = np.intersect1d(masked_indices, cropped_indices);
xyz_locs = np.column_stack((kk_flat[cropp_n_mask_ind], jj_flat[cropp_n_mask_ind], ii_flat[cropp_n_mask_ind]));
return xyz_locs, cropp_n_mask_ind, mask.shape;
def prepare_mask_and_maps_for_scaling(emmap, modelmap, apix, wn_locscale, windowSize, method, locResMap, noiseBox):
mask = np.zeros(emmap.shape);
if mask.shape[0] == mask.shape[1] and mask.shape[0] == mask.shape[2] and mask.shape[1] == mask.shape[2]:
rad = (mask.shape[0] // 2) ;
z,y,x = np.ogrid[-rad: rad+1, -rad: rad+1, -rad: rad+1];
mask = (x**2+y**2+z**2 <= rad**2).astype(np.int_).astype(np.int8);
mask = pad_or_crop_volume(mask,emmap.shape);
mask = (mask > 0.5).astype(np.int8);
else:
mask += 1;
mask = mask[0:mask.shape[0]-1, 0:mask.shape[1]-1, 0:mask.shape[2]-1];
mask = pad_or_crop_volume(emmap, (emmap.shape), pad_value=0);
if wn_locscale is None:
wn_locscale = int(round(7 * 3 * apix)); # set default window size to 7 times average resolution
elif wn_locscale is not None:
wn_locscale = int(math.ceil(wn_locscale / 2.) * 2);
#wn = wn_locscale;
if windowSize is None:
wn = wn_locscale;
elif windowSize is not None:
wn = int(math.ceil(windowSize / 2.) * 2);
if method is not None:
method = method;
else:
method = 'BY';
if noiseBox is not None:
boxCoord = noiseBox;
else:
boxCoord = 0;
window_bleed_and_pad = check_for_window_bleeding(mask, wn_locscale);
if window_bleed_and_pad:
pad_int_emmap = compute_padding_average(emmap, mask);
pad_int_modmap = compute_padding_average(modelmap, mask);
map_shape = [(emmap.shape[0] + wn_locscale), (emmap.shape[1] + wn_locscale), (emmap.shape[2] + wn_locscale)];
emmap = pad_or_crop_volume(emmap, map_shape, pad_int_emmap);
modelmap = pad_or_crop_volume(modelmap, map_shape, pad_int_modmap);
mask = pad_or_crop_volume(mask, map_shape, 0);
if locResMap is not None:
locResMap = pad_or_crop_volume(locResMap, map_shape, 100.0);
#if wished so, do local filtration
if locResMap is not None:
locResMap[locResMap == 0.0] = 100.0;
locResMap[locResMap >= 100.0] = 100.0;
locFilt = True;
else:
locFilt = False;
locResMap = np.ones(emmap.shape);
return emmap, modelmap, mask, wn, wn_locscale, window_bleed_and_pad, method, locFilt, locResMap, boxCoord;
def compute_radial_profile(volFFT, frequencyMap):
dim = volFFT.shape;
ps = np.real(np.abs(volFFT));
frequencies = np.fft.rfftfreq(dim[0]);
#frequencies = np.linspace(0, 0.5, int(math.ceil(dim[0]/2.0)));
bins = np.digitize(frequencyMap, frequencies);
bins = bins - 1;
radial_profile = np.bincount(bins.ravel(), ps.ravel()) / np.bincount(bins.ravel())
return radial_profile, frequencies;
def compute_scale_factors(em_profile, ref_profile):
np.seterr(divide='ignore', invalid='ignore'); #no error for division by zero
#scale_factor = (ref_profile**2/em_profile**2);
#scale_factor[ ~ np.isfinite( scale_factor )] = 0 #handle division by zero
#scale_factor = np.sqrt(scale_factor);
scale_factor = np.divide(np.abs(ref_profile), np.abs(em_profile));
scale_factor[ ~ np.isfinite( scale_factor )] = 0; #handle division by zero
return scale_factor;
def set_radial_profile(volFFT, scaleFactors, frequencies, frequencyMap, shape):
scalingMap = np.interp(frequencyMap, frequencies, scaleFactors);
scaledMapFFT = scalingMap * volFFT;
scaledMap = np.real(np.fft.irfftn(scaledMapFFT, shape, norm='ortho'));
return scaledMap, scaledMapFFT;
def calculate_scaled_map(emmap, modmap, mask, wn, wn_locscale, apix, locFilt, locResMap, boxCoord, ecdfBool, stepSize):
sizeMap = emmap.shape
sharpened_map = np.zeros(sizeMap);
sharpened_mean_vals = np.zeros(sizeMap);
sharpened_var_vals = np.zeros(sizeMap);
sharpened_ecdf_vals = np.zeros(sizeMap);
central_pix = int(round(wn_locscale / 2.0));
center = np.array([0.5*sizeMap[0], 0.5*sizeMap[1], 0.5*sizeMap[2]]);
#get the background noise sample
if boxCoord == 0:
noiseMap = emmap[int(center[0]-0.5*wn):(int(center[0]-0.5*wn) + wn), int(0.02*wn+wn_locscale/2.0):(int(0.02*wn+wn_locscale/2.0) + wn), (int(center[2]-0.5*wn)):(int((center[2]-0.5*wn) + wn))];
else:
noiseMap = emmap[int(boxCoord[0]-0.5*wn +wn_locscale/2.0):(int(boxCoord[0]-0.5*wn + wn_locscale/2.0) + wn), int(boxCoord[1]-0.5*wn+ wn_locscale/2.0):(int(boxCoord[1]-0.5*wn + wn_locscale/2.0) + wn), (int(boxCoord[2]-0.5*wn + wn_locscale/2.0)):(int((boxCoord[2]-0.5*wn + wn_locscale/2.0)+wn))];
#prepare noise map for scaling
frequencyMap_noise = FDRutil.calculate_frequency_map(noiseMap);
noiseMapFFT = np.fft.rfftn(noiseMap, norm='ortho');
noise_profile, frequencies_noise = compute_radial_profile(noiseMapFFT, frequencyMap_noise);
#prepare windows of particle for scaling
frequencyMap_mapWindow = FDRutil.calculate_frequency_map(np.zeros((wn_locscale, wn_locscale, wn_locscale)));
numSteps = len(range(0, sizeMap[0] - int(wn_locscale), stepSize))*len(range(0, sizeMap[1] - int(wn_locscale), stepSize))*len(range(0, sizeMap[2] - int(wn_locscale), stepSize));
print("Sart LocScale. This might take a minute ...");
counterSteps = 0;
for k in range(0, sizeMap[0] - int(wn_locscale), stepSize):
for j in range(0, sizeMap[1] - int(wn_locscale), stepSize):
for i in range(0, sizeMap[2] - int(wn_locscale), stepSize):
#print progress
counterSteps = counterSteps + 1;
progress = counterSteps/float(numSteps);
if counterSteps%(int(numSteps/20.0)) == 0:
output = "%.1f" %(progress*100) + "% finished ..." ;
print(output);
#crop windows
emmap_wn = emmap[k: k + wn_locscale, j: j + wn_locscale, i: i + wn_locscale];
modmap_wn = modmap[k: k + wn_locscale, j: j + wn_locscale, i: i + wn_locscale];
#do sharpening of the sliding window
emmap_wn_FFT = np.fft.rfftn(np.copy(emmap_wn), norm='ortho');
modmap_wn_FFT = np.fft.rfftn(np.copy(modmap_wn), norm='ortho');
em_profile, frequencies_map = compute_radial_profile(emmap_wn_FFT, frequencyMap_mapWindow);
mod_profile, _ = compute_radial_profile(modmap_wn_FFT, frequencyMap_mapWindow);
scale_factors = compute_scale_factors(em_profile, mod_profile);
map_b_sharpened, map_b_sharpened_FFT = set_radial_profile(emmap_wn_FFT, scale_factors, frequencies_map, frequencyMap_mapWindow, emmap_wn.shape);
#scale noise window with the interpolated scaling factors
mapNoise_sharpened, mapNoise_sharpened_FFT = set_radial_profile(np.copy(noiseMapFFT), scale_factors, frequencies_map, frequencyMap_noise, noiseMap.shape);
#local filtering routines
if locFilt == True:
tmpRes = round(apix/locResMap[k, j, i], 3);
mapNoise_sharpened = FDRutil.lowPassFilter(mapNoise_sharpened_FFT, frequencyMap_noise, tmpRes, noiseMap.shape);
map_b_sharpened = FDRutil.lowPassFilter(map_b_sharpened_FFT, frequencyMap_mapWindow, tmpRes, emmap_wn.shape);
#calculate noise statistics
map_noise_sharpened_data = mapNoise_sharpened;
if ecdfBool:
tmpECDF, sampleSort = FDRutil.estimateECDFFromMap(map_noise_sharpened_data, -1, -1);
ecdf = np.interp(map_b_sharpened[central_pix, central_pix, central_pix], sampleSort, tmpECDF, left=0.0, right=1.0);
else:
ecdf = 0;
mean = np.mean(map_noise_sharpened_data);
var = np.var(map_noise_sharpened_data);
if var < 0.5:
var = 0.5;
mean = 0.0;
if tmpRes == round(apix/100.0, 3):
mean = 0.0;
var = 0.0;
ecdf = 0;
else:
#calculate noise statistics
map_noise_sharpened_data = np.copy(mapNoise_sharpened);
if ecdfBool:
tmpECDF, sampleSort = FDRutil.estimateECDFFromMap(map_noise_sharpened_data, -1, -1);
ecdf = np.interp(map_b_sharpened, sampleSort, tmpECDF, left=0.0, right=1.0);
else:
ecdf = 0;
mean = np.mean(map_noise_sharpened_data);
var = np.var(map_noise_sharpened_data);
if var < 0.5:
var = 0.5;
mean = 0.0;
#put values back into the the original maps
halfStep=int((wn_locscale/2.0) - (stepSize/2.0));
sharpened_map[k + halfStep : k + halfStep + stepSize, j + halfStep : j + halfStep + stepSize, i + halfStep : i + halfStep + stepSize] = np.copy(map_b_sharpened[halfStep:halfStep+stepSize, halfStep:halfStep+stepSize, halfStep:halfStep+stepSize]);
sharpened_mean_vals[k + halfStep : k + halfStep + stepSize, j + halfStep : j + halfStep + stepSize, i + halfStep : i + halfStep + stepSize] = mean;
sharpened_var_vals[k + halfStep : k + halfStep + stepSize, j + halfStep : j + halfStep + stepSize, i + halfStep : i + halfStep + stepSize] = var;
if ecdfBool:
sharpened_ecdf_vals[k + halfStep : k + halfStep + stepSize, j + halfStep : j + halfStep + stepSize, i + halfStep : i + halfStep + stepSize] = ecdf[halfStep:halfStep+stepSize, halfStep:halfStep+stepSize, halfStep:halfStep+stepSize];
else:
sharpened_ecdf_vals[k + halfStep: k + halfStep + stepSize, j + halfStep: j + halfStep + stepSize,
i + halfStep: i + halfStep + stepSize] = 0.0;
return sharpened_map, sharpened_mean_vals, sharpened_var_vals, sharpened_ecdf_vals;
def get_central_scaled_pixel_vals_after_scaling(emmap, modmap, masked_xyz_locs, wn, wn_locscale, apix, locFilt, locResMap, boxCoord, ecdfBool):
sharpened_vals = [];
sharpened_mean_vals = [];
sharpened_var_vals = [];
sharpened_ecdf_vals = [];
central_pix = int(round(wn_locscale / 2.0));
sizeMap = emmap.shape;
center = np.array([0.5*sizeMap[0], 0.5*sizeMap[1], 0.5*sizeMap[2]]);
#get the background noise sample
if boxCoord == 0:
noiseMap = emmap[int(center[0]-0.5*wn):(int(center[0]-0.5*wn) + wn), int(0.02*wn+wn_locscale):(int(0.02*wn+wn_locscale) + wn), (int(center[2]-0.5*wn)):(int((center[2]-0.5*wn) + wn))];
else:
noiseMap = emmap[int(boxCoord[0]-0.5*wn + wn_locscale):(int(boxCoord[0]-0.5*wn + wn_locscale) + wn), int(boxCoord[1]-0.5*wn+ wn_locscale):(int(boxCoord[1]-0.5*wn + wn_locscale) + wn), (int(boxCoord[2]-0.5*wn + wn_locscale)):(int((boxCoord[2]-0.5*wn + wn_locscale)+wn))];
#prepare noise map for scaling
frequencyMap_noise = calculate_frequency_map(noiseMap);
noiseMapFFT = np.fft.rfftn(noiseMap);
noise_profile, frequencies_noise = compute_radial_profile(noiseMapFFT, frequencyMap_noise);
#prepare windows of particle for scaling
frequencyMap_mapWindow = calculate_frequency_map(np.zeros((wn_locscale, wn_locscale, wn_locscale)));
for k, j, i in (masked_xyz_locs - wn_locscale / 2.0):
emmap_wn = emmap[k: k+wn_locscale, j: j+wn_locscale, i: i+ wn_locscale];
modmap_wn = modmap[k: k+wn_locscale, j: j+wn_locscale, i: i+ wn_locscale];
#do sharpening of the sliding window
emmap_wn_FFT = np.fft.rfftn(np.copy(emmap_wn));
modmap_wn_FFT = np.fft.rfftn(np.copy(modmap_wn));
em_profile, frequencies_map = compute_radial_profile(emmap_wn_FFT, frequencyMap_mapWindow);
mod_profile, _ = compute_radial_profile(modmap_wn_FFT, frequencyMap_mapWindow);
scale_factors = compute_scale_factors(em_profile, mod_profile);
map_b_sharpened, map_b_sharpened_FFT = set_radial_profile(emmap_wn_FFT, scale_factors, frequencies_map, frequencyMap_mapWindow);
#do interpolation of sharpening factors
scale_factors_noise = np.interp(frequencies_noise, frequencies_map, scale_factors);
#scale noise window with the interpolated scaling factors
mapNoise_sharpened, mapNoise_sharpened_FFT = set_radial_profile(np.copy(noiseMapFFT), scale_factors_noise, frequencies_noise, frequencyMap_noise);
#local filtering routines
if locFilt == True:
tmpRes = round(apix/locResMap[k, j, i], 3);
mapNoise_sharpened = lowPassFilter(mapNoise_sharpened_FFT, frequencyMap_noise, tmpRes);
map_b_sharpened = lowPassFilter(map_b_sharpened_FFT, frequencyMap_mapWindow, tmpRes);
#calculate noise statistics
map_noise_sharpened_data = mapNoise_sharpened;
if ecdfBool:
tmpECDF, sampleSort = estimateECDFFromMap(map_noise_sharpened_data, -1, -1);
ecdf = | np.interp(map_b_sharpened[central_pix, central_pix, central_pix], sampleSort, tmpECDF, left=0.0, right=1.0) | numpy.interp |
# -*- coding: utf-8 -*-
"""
Created on Tue Apr 30 18:38:13 2019
@author: PRJ
"""
import numpy as np
import copy
def fillmissing(X_raw, missing = 'median'):
"""
Fill missing value with specific value
"""
X = copy.deepcopy(X_raw)
if len(X.shape) == 1:
N = X.shape[0]
if missing == 'mean':
X_fill = np.nanmean(X)
elif missing == 'median':
X_fill = np.nanmedian(X)
elif missing == 'max':
X_fill = np.nanmax(X)
elif missing == 'min':
X_fill = np.nanmin(X)
else:
X_fill = 0
for it in range(N):
X[it] = X_fill
else:
[N, M] = X.shape
if missing == 'mean':
X_fill = np.nanmean(X, axis = 0)
elif missing == 'median':
X_fill = np.nanmedian(X, axis = 0)
elif missing == 'max':
X_fill = np.nanmax(X, axis = 0)
elif missing == 'min':
X_fill = np.nanmin(X, axis = 0)
else:
X_fill = np.zeros(M)
for it in range(N):
for jt in range(M):
if | np.isnan(X[it,jt]) | numpy.isnan |
from __future__ import print_function, division, absolute_import
__author__ = '<NAME>'
from rep import utils
import numpy
import pandas
def test_calc():
prediction = numpy.random.random(10000)
iron = utils.Flattener(prediction)
assert numpy.allclose(numpy.histogram(iron(prediction), normed=True, bins=30)[0], numpy.ones(30), rtol=1e-02)
x, y, yerr, xerr = utils.calc_hist_with_errors(iron(prediction), bins=30, x_range=(0, 1))
assert numpy.allclose(y, numpy.ones(len(y)), rtol=1e-02)
width = 1. / 60
means = numpy.linspace(width, 1 - width, 30)
assert numpy.allclose(x, means)
assert numpy.allclose(xerr, numpy.zeros(len(xerr)) + width)
assert numpy.allclose(yerr, numpy.zeros(len(yerr)) + yerr[0], rtol=1e-2)
random_labels = numpy.random.choice(2, size=10000)
(tpr, tnr), _, _ = utils.calc_ROC(prediction, random_labels)
# checking for random classifier
assert numpy.max(abs(1 - tpr - tnr)) < 0.05
# checking efficiencies for random mass, random prediction
mass = numpy.random.random(10000)
result = utils.get_efficiencies(prediction, mass)
for threshold, (xval, yval) in result.items():
assert ((yval + threshold - 1) ** 2).mean() < 0.1
def test_train_test_split_group():
data = list(range(50)) * 2
group_column = list(range(50)) * 2
train, test = utils.train_test_split_group(group_column, data)
assert len(set.intersection(set(test), set(train))) == 0
def test_corr_coeff_with_weights(n_samples=1000):
"""
testing that corrcoeff with equal weights works as default.
"""
weights = numpy.ones(n_samples)
df = pandas.DataFrame(data=numpy.random.random([n_samples, 10]))
z1 = numpy.corrcoef(df.values.T)
z2 = utils.calc_feature_correlation_matrix(df)
z3 = utils.calc_feature_correlation_matrix(df, weights=weights)
assert numpy.allclose(z1, z2)
assert numpy.allclose(z1, z3)
def test_get_columns(n_samples=10000):
x = numpy.random.random([n_samples, 3])
df = pandas.DataFrame(x, columns=['a', 'b', 'c'])
result = utils.get_columns_in_df(df, ['a: a-b+b', 'b: b + 0 * c** 2.', 'c: c + 1 + c * (b - b)'])
result['c'] -= 1
assert not | numpy.allclose(result, df + 1e-3) | numpy.allclose |
import copy
import numpy as np
import logging
logger = logging.getLogger(__name__)
try:
from pycqed.analysis import machine_learning_toolbox as ml
except Exception:
logger.warning('Machine learning packages not loaded. '
'Run from pycqed.analysis import machine_learning_toolbox to see errors.')
from sklearn.model_selection import GridSearchCV as gcv, train_test_split
from scipy.optimize import fmin_l_bfgs_b,fmin,minimize,fsolve
def nelder_mead(fun, x0,
initial_step=0.1,
no_improve_thr=10e-6, no_improv_break=10,
maxiter=0,
alpha=1., gamma=2., rho=-0.5, sigma=0.5,
verbose=False):
'''
parameters:
fun (function): function to optimize, must return a scalar score
and operate over a numpy array of the same dimensions as x0
x0 (numpy array): initial position
initial_step (float/np array): determines the stepsize to construct
the initial simplex. If a float is specified it uses the same
value for all parameters, if an array is specified it uses
the specified step for each parameter.
no_improv_thr, no_improv_break (float, int): break after
no_improv_break iterations with an improvement lower than
no_improv_thr
maxiter (int): always break after this number of iterations.
Set it to 0 to loop indefinitely.
alpha (float): reflection coefficient
gamma (float): expansion coefficient
rho (float): contraction coefficient
sigma (float): shrink coefficient
For details on these parameters see Wikipedia page
return: tuple (best parameter array, best score)
Pure Python/Numpy implementation of the Nelder-Mead algorithm.
Implementation from https://github.com/fchollet/nelder-mead, edited by
<NAME> for use in PycQED.
Reference: https://en.wikipedia.org/wiki/Nelder%E2%80%93Mead_method
'''
# init
x0 = np.array(x0) # ensures algorithm also accepts lists
dim = len(x0)
prev_best = fun(x0)
no_improv = 0
res = [[x0, prev_best]]
if type(initial_step) is float:
initial_step_matrix = np.eye(dim)*initial_step
elif (type(initial_step) is list) or (type(initial_step) is np.ndarray):
if len(initial_step) != dim:
raise ValueError('initial_step array must be same lenght as x0')
initial_step_matrix = np.diag(initial_step)
else:
raise TypeError('initial_step ({})must be list or np.array'.format(
type(initial_step)))
for i in range(dim):
x = copy.copy(x0)
x = x + initial_step_matrix[i]
score = fun(x)
res.append([x, score])
# simplex iter
iters = 0
while 1:
# order
res.sort(key=lambda x: x[1])
best = res[0][1]
# break after maxiter
if maxiter and iters >= maxiter:
# Conclude failure break the loop
if verbose:
print('max iterations exceeded, optimization failed')
break
iters += 1
if best < prev_best - no_improve_thr:
no_improv = 0
prev_best = best
else:
no_improv += 1
if no_improv >= no_improv_break:
# Conclude success, break the loop
if verbose:
print('No improvement registered for {} rounds,'.format(
no_improv_break) + 'concluding succesful convergence')
break
# centroid
x0 = [0.] * dim
for tup in res[:-1]:
for i, c in enumerate(tup[0]):
x0[i] += c / (len(res)-1)
# reflection
xr = x0 + alpha*(x0 - res[-1][0])
rscore = fun(xr)
if res[0][1] <= rscore < res[-2][1]:
del res[-1]
res.append([xr, rscore])
continue
# expansion
if rscore < res[0][1]:
xe = x0 + gamma*(x0 - res[-1][0])
escore = fun(xe)
if escore < rscore:
del res[-1]
res.append([xe, escore])
continue
else:
del res[-1]
res.append([xr, rscore])
continue
# contraction
xc = x0 + rho*(x0 - res[-1][0])
cscore = fun(xc)
if cscore < res[-1][1]:
del res[-1]
res.append([xc, cscore])
continue
# reduction
x1 = res[0][0]
nres = []
for tup in res:
redx = x1 + sigma*(tup[0] - x1)
score = fun(redx)
nres.append([redx, score])
res = nres
# once the loop is broken evaluate the final value one more time as
# verification
fun(res[0][0])
return res[0]
def SPSA(fun, x0,
initial_step=0.1,
no_improve_thr=10e-6, no_improv_break=10,
maxiter=0,
gamma=0.101, alpha=0.602, a=0.2, c=0.3, A=300,
p=0.5, ctrl_min=0.,ctrl_max=np.pi,
verbose=False):
'''
parameters:
fun (function): function to optimize, must return a scalar score
and operate over a numpy array of the same dimensions as x0
x0 (numpy array): initial position
no_improv_thr, no_improv_break (float, int): break after
no_improv_break iterations with an improvement lower than
no_improv_thr
maxiter (int): always break after this number of iterations.
Set it to 0 to loop indefinitely.
alpha, gamma, a, c, A, (float): parameters for the SPSA gains
(see refs for definitions)
p (float): probability to get 1 in Bernoulli +/- 1 distribution
(see refs for context)
ctrl_min, ctrl_max (float/array): boundaries for the parameters.
can be either a global boundary for all dimensions, or a
numpy array containing the boundary for each dimension.
return: tuple (best parameter array, best score)
alpha, gamma, a, c, A and p, are parameters for the algorithm.
Their function is described in the references below,
and even optimal values have been discussed in the literature.
Pure Python/Numpy implementation of the SPSA algorithm designed by Spall.
Implementation from http://www.jhuapl.edu/SPSA/PDF-SPSA/Spall_An_Overview.PDF,
edited by <NAME> for use in PycQED.
Reference: http://www.jhuapl.edu/SPSA/Pages/References-Intro.htm
'''
# init
x0 = np.array(x0) # ensures algorithm also accepts lists
dim = len(x0)
prev_best = fun(x0)
no_improv = 0
res = [[x0, prev_best]]
x = copy.copy(x0)
# SPSA iter
iters = 0
while 1:
# order
res.sort(key=lambda x: x[1])
best = res[0][1]
# break after maxiter
if maxiter and iters >= maxiter:
# Conclude failure break the loop
if verbose:
print('max iterations exceeded, optimization failed')
break
iters += 1
if best < prev_best - no_improve_thr:
no_improv = 0
prev_best = best
else:
no_improv += 1
if no_improv >= no_improv_break:
# Conclude success, break the loop
if verbose:
print('No improvement registered for {} rounds,'.format(
no_improv_break) + 'concluding succesful convergence')
break
# step 1
a_k = a/(iters+A)**alpha
c_k = c/iters**gamma
# step 2
delta = np.where(np.random.rand(dim) > p, 1, -1)
# step 3
x_plus = x+c_k*delta
x_minus = x-c_k*delta
y_plus = fun(x_plus)
y_minus = fun(x_minus)
# res.append([x_plus, y_plus])
# res.append([x_minus, y_minus])
# step 4
gradient = (y_plus-y_minus)/(2.*c_k*delta)
# step 5
x = x-a_k*gradient
x = np.where(x < ctrl_min, ctrl_min, x)
x = np.where(x > ctrl_max, ctrl_max, x)
score = fun(x)
res.append([x, score])
# once the loop is broken evaluate the final value one more time as
# verification
fun(res[0][0])
return res[0]
def generate_new_training_set(new_train_values, new_target_values,
training_grid=None, target_values=None):
if training_grid is None:
training_grid =new_train_values
target_values = new_target_values
else:
if np.shape(new_train_values)[1] != np.shape(training_grid)[1] or \
np.shape(new_target_values)[1] != np.shape(target_values)[1]:
print('Shape missmatch between new training values and existing ones!'
' Returning None.')
return None,None
training_grid = np.append(training_grid,new_train_values,axis=0)
target_values = np.append(target_values,new_target_values,axis=0)
return training_grid,target_values
def center_and_scale(X_in,y_in):
'''
Preprocessing of Data. Mainly transform the data to mean 0 and interval [-1,1]
:param X: training data list of parameters (each equally long). Standing vector!
:param y: validation data list of parameters (each equally long).Standing vector!
:output:
:X: rescaled and centered training data
:y: rescaled and centered test data
:input_feature_means: mean values of initial training data parameters
:output_feature_means: mean values of initial validation data parameters
:input_feature_ext: abs(max-min) of initial training data parameters
:output_feature_ext: abs(max-min) of initial validation data parameters
'''
if not isinstance(X_in,np.ndarray):
X_in = np.array(X_in)
if X_in.ndim == 1:
X_in.shape = (np.size(X_in),X_in.ndim)
#X_in.reshape((np.size(X_in),X_in.ndim))
if not isinstance(y_in,np.ndarray):
y_in= np.array(y_in)
if y_in.ndim == 1:
#y_in.reshape((np.size(y_in),y_in.ndim))
y_in.shape = (np.size(y_in),y_in.ndim)
X = copy.deepcopy(X_in)
y = copy.deepcopy(y_in)
input_feature_means = np.zeros(np.size(X,1)) #saving means of training
output_feature_means = np.zeros(np.size(y,1)) #and target features
input_feature_ext= np.zeros(np.size(X,1))
output_feature_ext = np.zeros(np.size(y,1))
if np.size(X,1)==1:
input_feature_means= [np.mean(X)]
input_feature_ext = [np.max(X) \
-np.min(X)]
X -= input_feature_means #offset to mean 0
X /= input_feature_ext #rescale to [-1,1]
else:
for it in range(np.size(X,1)):
input_feature_means[it]= np.mean(X[:,it])
input_feature_ext[it] = np.max(X[:,it]) \
-np.min(X[:,it])
X[:,it] -= input_feature_means[it] #offset to mean 0
X[:,it] /= input_feature_ext[it] #rescale to [-1,1]
if np.size(y,1) == 1:
output_feature_means= [np.mean(y)]
output_feature_ext = [np.max(y) \
-np.min(y)]
y -= output_feature_means #offset to mean 0
y /= output_feature_ext #rescale to [-1,1]
else:
for it in range(np.size(y,1)):
output_feature_means[it]= np.mean(y[:,it])
output_feature_ext[it] = np.max(y[:,it]) \
-np.min(y[:,it])
y[:,it] -= output_feature_means[it] #offset to mean 0
y[:,it] /= output_feature_ext[it] #rescale to [-1,1]
return X,y,\
input_feature_means,input_feature_ext,\
output_feature_means,output_feature_ext
def neural_network_opt(fun, training_grid, target_values = None,
estimator='GRNN_neupy',hyper_parameter_dict=None,
x_init = None):
"""
parameters:
fun: Function that can be used to get data points if None,
target_values have to be provided instead.
training_grid: The values on which to train the Neural Network. It
contains features as column vectors of length as the
number of datapoints in the training set.
target_values: The target values measured during data acquisition by a
hard sweep over the traning grid.
estimator: The estimator used to model the function mapping the
training_grid on the target_values.
hyper_parameter_dict: if None, the default hyperparameters
of the selected estimator are used. Should contain
estimator dependent hyperparameters such as hidden
layer sizes for a neural network. See
<machine_learning_toolbox> for specific
information on available estimators.
x_ini: Initial values for the minimization of the fitted function.
output:
optimal points where network is minimized.
est: estimator instance representing the trained model. Consists of a
predict(X) method, which computes the network response for a given
input value X.
"""
###############################################################
### create measurement data from test_grid ###
###############################################################
#get input dimension, training grid contains parameters as row(!!) vectors
if len(np.shape(training_grid)) == 1:
training_grid = np.transpose(np.array([training_grid]))
n_samples = np.size(training_grid,0)
print('Nr Samples: ', n_samples)
n_features = np.size(training_grid,1)
print('Nr Features: ', n_features)
if fun is None:
output_dim = np.size(target_values,1)
else:
#if the sweep is adaptive, acquire data points by applying fun
first_value = fun(training_grid[0])
output_dim = np.size(first_value)
target_values = np.zeros((n_samples,output_dim))
target_values[0,:] = first_value
for i in range(1,n_samples):
target_values[i,:]=fun(training_grid[i])
#Preprocessing of Data. Mainly transform the data to mean 0 and interval [-1,1]
training_grid_centered,target_values_centered,\
input_feature_means,input_feature_ext,\
output_feature_means,output_feature_ext \
= center_and_scale(training_grid,target_values)
#Save the preprocessing information in order to be able to rescale the values later.
pre_processing_dict ={'output': {'scaling': output_feature_ext,
'centering':output_feature_means},
'input': {'scaling': input_feature_ext,
'centering':input_feature_means}}
##################################################################
### initialize grid search cross val with hyperparameter dict. ###
### and MLPR instance and fit a model functione to fun() ###
##################################################################
def mlpr():
est = ml.MLP_Regressor_scikit(hyper_parameter_dict,
output_dim=output_dim,
n_feature=n_samples,
pre_proc_dict=pre_processing_dict)
est.fit(training_grid_centered, np.ravel(target_values_centered))
est.print_best_params()
return est
def dnnr():
est = ml.DNN_Regressor_tf(hyper_parameter_dict,
output_dim=output_dim,
n_feature=n_features,
pre_proc_dict=pre_processing_dict)
est.fit(training_grid_centered,target_values_centered)
return est
def grnn():
est = ml.GRNN_neupy(hyper_parameter_dict,
pre_proc_dict=pre_processing_dict)
cv_est = ml.CrossValidationEstimator(hyper_parameter_dict,est)
cv_est.fit(training_grid_centered,target_values_centered)
return cv_est
def polyreg():
est = ml.Polynomial_Regression(hyper_parameter_dict,
pre_proc_dict=pre_processing_dict)
est.fit(training_grid_centered,target_values_centered)
return est
estimators = {'MLP_Regressor_scikit': mlpr, #defines all current estimators currently implemented
'DNN_Regressor_tf': dnnr,
'GRNN_neupy': grnn,
'Polynomial_Regression_scikit': polyreg}
est = estimators[estimator]() #create and fit instance of the chosen estimator
def estimator_wrapper(X):
pred = est.predict([X])
print('pred: ', pred)
if output_dim == 1.:
return | np.abs(pred+1.) | numpy.abs |
#!/usr/bin/env python
# coding: utf-8
### About
# Simulating asset prices using Monte Carlo Simulations.
### Code
import sys
import os
import logging
import numpy as np
import pandas as pd
import boto3
from botocore.exceptions import ClientError
# N.B.: Don't set random seed as we want randomness in our Monte Carlo simulations!
# np.random.seed(42)
## ENVIRONMENT VARIABLES
# No. of days to perform Monte Carlo simulations for
N_PERIODS = os.getenv("N_PERIODS")
# No. of Monte Carlo simulations to run in this job
N_SIMS = os.getenv("N_SIMS")
# bucket name to upload final results to
BUCKET_NAME = os.getenv("AWS_BUCKET")
# Folder for storing all data for this Batch job
JOB_NAME = os.getenv("JOB_NAME")
# get index of AWS Batch array job that this job is assigned
JOB_INDEX = os.getenv("AWS_BATCH_JOB_ARRAY_INDEX")
## Helper functions
def check_env_var(a_var, a_var_name):
""" Check that an expected environment variable is actually present.
:param a_var: Variable to be checked
:param a_var_name: Name of environment variable that should be present
:return: None; exit program if variable is not present
"""
if a_var is None:
print(f"Environment variable {a_var_name} is not present!")
sys.exit(2)
# endif #
# enddef check_env_var() #
def upload_file(file_name, bucket, object_name=None):
"""Upload a file to an S3 bucket
:param file_name: File to upload
:param bucket: Bucket to upload to
:param object_name: S3 object name. If not specified then file_name is used
:return: True if file was uploaded, else False
"""
# If S3 object_name was not specified, use file_name
if object_name is None:
object_name = os.path.basename(file_name)
# endif #
# Upload the file
s3_client = boto3.client('s3')
try:
response = s3_client.upload_file(file_name, bucket, object_name)
except ClientError as e:
logging.error(e)
return False
# endtry #
return True
# enddef upload_file() #
def get_input_csv(bucket_name, file_name):
""" Download and read CSV file from an S3 bucket
:param bucket_name: Bucket in which CSV file is located
:param file_name: key name of the CSV file to read
:return: DataFrame constructed from CSV file
"""
s3 = boto3.client('s3')
response = s3.get_object(Bucket=bucket_name, Key=file_name)
status = response.get("ResponseMetadata", {}).get("HTTPStatusCode")
if status == 200:
print(f"Retrieved file {file_name} from bucket {bucket_name}")
return pd.read_csv(response.get("Body"), index_col=0)
else:
print(f"Error in retrieving file {file_name} from bucket {bucket_name}; {status}")
sys.exit(1)
# endif #
# enddef get_input_csv() #
# check all required environment variables are defined
check_env_var(N_PERIODS, "N_PERIODS")
check_env_var(N_SIMS, "N_SIMS")
check_env_var(BUCKET_NAME, "AWS_BUCKET")
check_env_var(JOB_NAME, "JOB_NAME")
check_env_var(JOB_INDEX, "AWS_BATCH_JOB_ARRAY_INDEX")
# convert to appropriate data type
N_PERIODS = int(N_PERIODS)
N_SIMS = int(N_SIMS)
# get asset prices from CSV file in S3 bucket
asset_prices = get_input_csv(BUCKET_NAME, JOB_NAME+"/input/asset_prices.csv")
# compute the quantities in Eq.(1) above from the data
log_returns = np.log(1 + asset_prices.pct_change())
u = log_returns.mean()
var = log_returns.var()
drift = u - (0.5*var)
stdev = log_returns.std()
# generate standard normal variate of required size
if len(u) > 1:
Z = np.random.multivariate_normal(mean=[0]*len(u), cov=log_returns.cov(), size=(N_PERIODS, N_SIMS))
else:
Z = np.random.normal(size=(N_PERIODS, N_SIMS))
# endif #
# since mu and sigma are daily values, dt=1
daily_returns = np.exp(drift.values + stdev.values * Z)
price_paths = | np.zeros_like(daily_returns) | numpy.zeros_like |
# Copyright 2015 The TensorFlow Authors. 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.
# ==============================================================================
"""Tests for tensorflow.ops.one_hot_op."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import tensorflow as tf
class OneHotTest(tf.test.TestCase):
def _testOneHot(self, truth, use_gpu=False, expected_err_re=None,
raises=None, **inputs):
with self.test_session(use_gpu=use_gpu):
if raises is not None:
with self.assertRaises(raises):
tf.one_hot(**inputs)
else:
ans = tf.one_hot(**inputs)
if expected_err_re is None:
tf_ans = ans.eval()
self.assertAllEqual(tf_ans, truth)
self.assertEqual(tf_ans.shape, ans.get_shape())
else:
with self.assertRaisesOpError(expected_err_re):
ans.eval()
def _testBothOneHot(self, truth, expected_err_re=None, raises=None, **inputs):
self._testOneHot(truth, True, expected_err_re, raises, **inputs)
self._testOneHot(truth, False, expected_err_re, raises, **inputs)
def _testBasic(self, dtype):
indices = np.asarray([0, 2, -1, 1], dtype=np.int64)
depth = 3
on_value = np.asarray(1.0, dtype=dtype)
off_value = np.asarray(-1.0, dtype=dtype)
truth = np.asarray(
[[1.0, -1.0, -1.0],
[-1.0, -1.0, 1.0],
[-1.0, -1.0, -1.0],
[-1.0, 1.0, -1.0]],
dtype=dtype)
# axis == -1
self._testBothOneHot(
indices=indices,
depth=depth,
on_value=on_value,
off_value=off_value,
dtype=dtype,
truth=truth)
# axis == 0
self._testBothOneHot(
indices=indices,
depth=depth,
on_value=on_value,
off_value=off_value,
axis=0,
dtype=dtype,
truth=truth.T) # Output is transpose version in this case
def _testDefaultBasic(self, dtype):
indices = np.asarray([0, 2, -1, 1], dtype=np.int64)
depth = 3
truth = np.asarray(
[[1.0, 0.0, 0.0],
[0.0, 0.0, 1.0],
[0.0, 0.0, 0.0],
[0.0, 1.0, 0.0]],
dtype=dtype)
# axis == -1
self._testBothOneHot(
indices=indices,
depth=depth,
truth=truth)
# axis == 0
self._testBothOneHot(
indices=indices,
depth=depth,
axis=0,
truth=truth.T) # Output is transpose version in this case
def testFloatBasic(self):
self._testBasic(np.float32)
self._testDefaultBasic(np.float32)
def testDoubleBasic(self):
self._testBasic(np.float64)
self._testDefaultBasic(np.float64)
def testInt32Basic(self):
self._testBasic(np.int32)
self._testDefaultBasic(np.int32)
def testInt64Basic(self):
self._testBasic(np.int64)
self._testDefaultBasic(np.int64)
def testComplex64Basic(self):
self._testBasic(np.complex64)
self._testDefaultBasic(np.complex64)
def testComplex128Basic(self):
self._testBasic(np.complex128)
self._testDefaultBasic(np.complex128)
def _testBatch(self, dtype):
indices = np.asarray([[0, 2, -1, 1],
[1, 0, 1, -1]],
dtype=np.int64)
depth = 3
on_value = np.asarray(1.0, dtype=dtype)
off_value = np.asarray(-1.0, dtype=dtype)
truth = np.asarray(
[[[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]]],
dtype=dtype)
# axis == -1
self._testBothOneHot(
indices=indices,
depth=depth,
on_value=on_value,
off_value=off_value,
dtype=dtype,
truth=truth)
# axis == 1
self._testBothOneHot(
indices=indices,
depth=depth,
on_value=on_value,
off_value=off_value,
axis=1,
dtype=dtype,
truth=[truth[0].T, truth[1].T]) # Do not transpose the batch
def _testDefaultValuesBatch(self, dtype):
indices = np.asarray([[0, 2, -1, 1],
[1, 0, 1, -1]],
dtype=np.int64)
depth = 3
truth = np.asarray(
[[[1.0, 0.0, 0.0],
[0.0, 0.0, 1.0],
[0.0, 0.0, 0.0],
[0.0, 1.0, 0.0]],
[[0.0, 1.0, 0.0],
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 0.0]]],
dtype=dtype)
# axis == -1
self._testBothOneHot(
indices=indices,
depth=depth,
dtype=dtype,
truth=truth)
# axis == 1
self._testBothOneHot(
indices=indices,
depth=depth,
axis=1,
dtype=dtype,
truth=[truth[0].T, truth[1].T]) # Do not transpose the batch
def _testValueTypeBatch(self, dtype):
indices = np.asarray([[0, 2, -1, 1],
[1, 0, 1, -1]],
dtype=np.int64)
depth = 3
on_value = | np.asarray(1.0, dtype=dtype) | numpy.asarray |
# Reverse photography
##h3D-II sensor size
# 36 * 48 mm, 0.036 x 0.048m
## focal length
# 28mm, 0.028m
## multiplier
# 1.0
from skimage import io
import matplotlib.pyplot as plt
import numpy as np
import cv2
from scipy.spatial import distance
import shapefile as shp
def buildshape(corners, filename):
"""build a shapefile geometry from the vertices of the image in
world coordinates, then save it using the image name. Sub critical"""
#create a shapefile instance
#shape = shp.writer(shape.POLYGON)
#shape.poly(parts = [[proj_coords[:,0], proj_coords[:,1]], [proj_coords[:,1], proj_coords[:,2]]
# [proj_coords[:,3], proj_coords[:,2]], [proj_coords[:,0], proj_coords[:,3]]]
#shape.save("./", filename)
def worldfile(corners, im_pix, filename, filepath):
"""build a world file from the vertices of the image in
world coordinates, then save it using the image name.
here we build a small array and then dump it to a file
input is:
- the image file name
- projected corners in world coordinates (*not* bounding box)
- pxel resolution as a two-element vector [pix_x, pix_y]
- path to warped image files
reference:
http://support.esri.com/en/knowledgebase/techarticles/detail/17489
"""
world_arr = np.zeros([6,1])
#line 1 is the X pixel resolution in M
world_arr[0] = im_pix[0]
#line 2 is the Y pixel resolution in M
world_arr[3] = -im_pix[1]
#now the X coord of the top left corner
world_arr[4] = np.min(corners[0,:])
#and the Y coordinate of the top left corner
world_arr[5] = np.max(corners[1,:])
#strip some parts from the filename
filename = filename[0:len(filename)-4]
np.savetxt(filepath + filename + '.jpgw', world_arr, "%.3f")
#------
# 2D homogeneous vectors and transformations
def hom2(x, y):
"""2D homogeneous column vector."""
return np.matrix([x, y, 1]).T
def scale2d(s_x, s_y):
"""Scale matrix that scales 2D homogeneous coordinates"""
return np.matrix([[s_x, 0, 0],
[0, s_y, 0],
[0, 0, 1]] )
def trans2d(t_x, t_y):
"""Translation matrix that moves a (homogeneous) vector [v_x, v_y, 1]
to [v_x + t_x, v_y + t_y, 1]"""
return np.matrix([[1, 0, t_x],
[0, 1, t_y],
[0, 0, 1]] )
#-----
# 3D homogeneous vectors and transformations
def hom3(x, y, z):
"""3D homogeneous column vector."""
return np.matrix([x, y, z, 1]).T
def unhom(v):
"""Convert homogeneous coords (v_x, v_y, v_z, v_w) to 3D by
(v_x, v_y, v_z) / v_w."""
return v[:-1]/v[-1]
def trans3d(t):
"""Translation matrix that moves a (homogeneous) vector [v_x, v_y, v_z, 1]
to [v_x + t_x, v_y + t_y, v_z + t_z, 1]."""
I = np.matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0]])
return np.hstack([I, t])
# return np.matrix([[1, 0, 0, t_x],
# [0, 1, 0, t_y],
# [0, 0, 1, t_z],
# [0, 0, 0, 1 ]] )
def persp3d(v_x, v_y, v_z):
"""Perspective transformation in homogeneous coordinates
where v represents the viewer's position relative to the
display surface (i.e., (v_x, v_y) is centre, v_z is focal
distance."""
return np.matrix([[1, 0, -v_x/v_z, 0],
[0, 1, -v_y/v_z, 0],
[0, 0, 1, 0],
[0, 0, 1/v_z, 0]] )
def cross(a, b):
"""Compute 3D cross product of homogeneous vectors, returning
the result as a 3D column vector."""
a3, b3 = unhom(a), unhom(b)
return np.matrix( | np.cross(a3.T, b3.T) | numpy.cross |
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 7 17:37:57 2021
@author: jagtaps
"""
import numpy as np
import networkx as nx
import pandas as pd
import requests
import gzip
import shutil
import mygene
import functions as f
mirna_dat_normal = pd.read_csv("data//Pancancer_miRNA_Normal.csv" )
mirna_dat_tumor = pd.read_csv("data//Pancancer_miRNA_Tumor.csv" )
mrna_dat_normal = pd.read_csv("data//Pancancer_mRNA_Normal.csv" )
mrna_dat_tumor = pd.read_csv("data//Pancancer_mRNA_Tumor.csv" )
ref_net = nx.read_edgelist("data//ref_net")
mirna_all = pd.concat([mirna_dat_normal, mirna_dat_tumor], axis=1)
mirna_all = mirna_all.loc[:,~mirna_all.columns.duplicated()]
mrna_all = pd.concat([mrna_dat_normal, mrna_dat_tumor], axis=1)
mrna_all = mrna_all.loc[:,~mrna_all.columns.duplicated()]
mirna_dat_N_mean = mirna_dat_normal.iloc[:,1:mirna_dat_normal.shape[1]].mean(axis=1)
mirna_dat_T_mean = mirna_dat_tumor.iloc[:,1:mirna_dat_tumor.shape[1]].mean(axis=1)
mrna_dat_N_mean = mrna_dat_normal.iloc[:,1:mrna_dat_normal.shape[1]].mean(axis=1)
mrna_dat_T_mean = mrna_dat_tumor.iloc[:,1:mrna_dat_tumor.shape[1]].mean(axis=1)
d = {'mirna' : np.array(mirna_dat_normal['miRNA'].values),'logFC' : np.log2(np.array(mirna_dat_T_mean)/np.array(mirna_dat_N_mean))}
mirna_fc_dat = pd.DataFrame(d)
mirna_fc_dat = mirna_fc_dat[mirna_fc_dat['logFC']>2]
mirna_fc_dat_overxp = mirna_fc_dat.replace([np.inf, -np.inf], np.nan).dropna(axis=0)
d = {'mrna' : np.array(mrna_dat_normal['mRNA'].values),'logFC' : np.log2(np.array(mrna_dat_T_mean)/np.array(mrna_dat_N_mean))}
mrna_fc_dat = pd.DataFrame(d)
mrna_fc_dat = mrna_fc_dat[mrna_fc_dat['logFC']<-2]
mrna_fc_dat_underexp = mrna_fc_dat.replace([np.inf, -np.inf], np.nan).dropna(axis=0)
mirna_overexp_dat = mirna_all.iloc[mirna_fc_dat_overxp.index]
mirna_overexp_datt = mirna_overexp_dat.iloc[:,1:mirna_overexp_dat.shape[1]]
mirna_overexp_datt.index = mirna_overexp_dat['miRNA'].values
mirna_coexp_dat = mirna_overexp_datt.transpose().corr().stack().reset_index()
mirna_coexp_dat = mirna_coexp_dat[mirna_coexp_dat[0]>0.8]
mirna_coexp_dat.to_csv('mirna.coexpnet', sep='\t',index= None)
mrna_overexp_dat = mrna_all.iloc[mrna_fc_dat_underexp.index]
mrna_overexp_datt = mrna_overexp_dat.iloc[:,1:mrna_overexp_dat.shape[1]]
mrna_overexp_datt.index = mrna_overexp_dat['mRNA'].values
mrna_coexp_dat = mrna_overexp_datt.transpose().corr().stack().reset_index()
mrna_coexp_dat = mrna_coexp_dat[mrna_coexp_dat[0]>0.8]
mrna_coexp_dat.to_csv('mrna.coexpnet', sep='\t',index= None)
mirna_mrna_coexp = pd.concat([mirna_coexp_dat,mrna_coexp_dat])
mirna_mrna_coexp_edgelist = mirna_mrna_coexp[['level_0','level_1']]
mirna_fc_dat_overxp.to_csv('mirna_fc_dat_overxp')
mrna_fc_dat_underexp.to_csv('mrna_fc_dat_underexp')
url = 'http://mirdb.org/mirdb/download/miRDB_v6.0_prediction_result.txt.gz'
r = requests.get(url)
with open('mirdb', 'wb') as f_in:
f_in.write(r.content)
with gzip.open('mirdb', 'rb') as f_in:
with open('mirdb.txt', 'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
mirna_db = pd.read_csv("miRDB_v6.0_prediction_result.txt", sep="\t", header=None)
mirna_db = mirna_db[mirna_db[0].isin(np.array(mirna_fc_dat_overxp['mirna']))]
mirna_db = mirna_db[mirna_db[2]>80]
mg = mygene.MyGeneInfo()
res = pd.DataFrame(mg.querymany(list(mirna_db[1].values), scopes='refseq'))
mirna_mrna_target = pd.DataFrame({'level_0': mirna_db[0].values, 'level_1' : res['symbol'].values})
mirna_mrna_target=mirna_mrna_target[mirna_mrna_target['level_1'].isin(np.array(mrna_fc_dat_underexp['mrna']))]
input_edgelist = pd.concat([mirna_mrna_coexp_edgelist,mirna_mrna_target])
input_edgelist.to_csv('input_edgelist', sep='\t',index= None, header = None)
e1 = nx.read_edgelist('input_edgelist')
a1 = nx.adjacency_matrix(e1)
m1 = f.PPMI_matrix(a1,2,1)
emb1 = f.embedd(m1,128)
dat = pd.DataFrame(data = emb1)
dat.index = e1.nodes
dat.to_csv('test_branet.emb', sep=' ')
mirna_list = mirna_fc_dat_overxp['mirna']
mrna_list =mrna_fc_dat_underexp['mrna']
top_mirna = mirna_fc_dat_overxp[:10]
mirna_list = top_mirna['mirna']
Mat = dat.values @ dat.values.transpose()
MatNorm = (Mat-Mat.min())/(Mat.max()-Mat.min())
Mat = pd.DataFrame(MatNorm,columns= | np.array(dat.index) | numpy.array |
#!/usr/bin/env python
# ----------------------------------------------------------------
# Programmer(s): <NAME> @ SMU
# ----------------------------------------------------------------
# SUNDIALS Copyright Start
# Copyright (c) 2002-2022, Lawrence Livermore National Security
# and Southern Methodist University.
# All rights reserved.
#
# See the top-level LICENSE and NOTICE files for details.
#
# SPDX-License-Identifier: BSD-3-Clause
# SUNDIALS Copyright End
# ----------------------------------------------------------------
# matplotlib-based plotting script
# ----------------------------------------------------------------
# imports
import glob
import sys
import pylab as plt
import numpy as np
# load mesh data file
mesh = np.loadtxt('mesh.txt', dtype=np.double)
# load output time file
times = np.loadtxt('t.000000.txt', dtype=np.double)
# load solution data files
ufiles = glob.glob('u.' + ('[0-9]'*6) + '.txt'); ufiles.sort()
vfiles = glob.glob('v.' + ('[0-9]'*6) + '.txt'); vfiles.sort()
wfiles = glob.glob('w.' + ('[0-9]'*6) + '.txt'); wfiles.sort()
udata = np.loadtxt(ufiles[0], dtype=np.double)
vdata = | np.loadtxt(vfiles[0], dtype=np.double) | numpy.loadtxt |
from flask import Flask, render_template, request
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
import sympy as sym
import imageio
import time
app = Flask(__name__)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/curiosities')
def curiosities_and_wonders():
return render_template('curiosities.html')
@app.route('/grad_des')
def grad_des():
return render_template('grad_des.html', string_variable="gradient_descent",
startx="-20", endx="20", starty="-20", endy="20",
q00="1", q01="0", q10="0", q11="-1", b0="0", b1="0", c="0", x0="-15", y0="0.1",
precision="0.0001", eps="0.05", max_iter="75")
@app.route('/steepest_des')
def steepest_des():
return render_template('steepest_des.html', string_variable="steepest_descent",
startx="-20", endx="20", starty="-20", endy="20",
q00="1", q01="0", q10="0", q11="2", b0="0", b1="0", c="0", x0="-15", y0="-15",
precision="0.0001", max_iter="50")
@app.route('/gdm')
def gdm():
return render_template('gdm.html', string_variable="gdm",
startx="-20", endx="20", starty="-20", endy="20",
q00="1", q01="0", q10="0", q11="-1", b0="0", b1="0", c="0", x0="-15", y0="0.1",
precision="0.0001", alpha="0.1", beta="0.9", max_iter="70")
@app.route('/rmsprop')
def RMSprop():
return render_template('rmsprop.html', string_variable="rmsprop",
startx="-20", endx="20", starty="-20", endy="20",
q00="1", q01="0", q10="0", q11="-1", b0="0", b1="0", c="0", x0="-15", y0="0.1",
precision="0.0001", alpha="0.2", beta="0.9", max_iter="80")
@app.route('/adam')
def adam_alg():
return render_template('adam.html', string_variable="adam",
startx="-20", endx="20", starty="-20", endy="20",
q00="1", q01="0", q10="0", q11="-1", b0="0", b1="0", c="0", x0="-15", y0="0.1",
precision="0.0001", alpha="0.2", beta1="0.9", beta2="0.999", max_iter="80", eps="0.00000001")
def f(x, q, b, c, n=2):
z = np.zeros(len(x))
for i in range(len(x)):
for j in range(int(n)):
for k in range(int(n)):
z[i] += q[j][k] * x[i][j] * x[i][k]
for j in range(int(n)):
z[i] += b[j] * x[i][j]
z[i] += c
return z
def f2(x, y, q, b, c):
z = q[0][0] * x * x + q[0][1] * x * y + q[1][0] * y * x + q[1][1] * y * y + b[0] * x + b[1] * y + c
return z
def f_mesh(x, y, q, b, c):
z = np.zeros(len(x))
z = q[0][0] * x * x + q[0][1] * x * y + q[1][0] * y * x + q[1][1] * y * y + b[0] * x + b[1] * y + c
return z
def z_func(x_old, q, b, c, eps=0.000000000001):
x, y, t = sym.symbols('x y t')
x1 = sym.Matrix([[x, y]])
t1 = sym.Matrix([[t]])
df = sym.Matrix([[sym.diff(f2(x, y, q, b, c), x),
sym.diff(f2(x, y, q, b, c), y)]])
z = x1 - t1 * df
z = f2(z[0], z[1], q, b, c)
z_diff = sym.diff(z, t)
eqn = sym.Eq(z_diff, 0)
sol = sym.solve(eqn, t)
sym.expr = sol[0]
sym.expr = sym.expr.subs([(x, x_old[0][0]), (y, x_old[0][1] + eps)])
print("sym: ", sym.expr )
return sym.expr
def init(start_x, end_x, start_y, end_y):
X1 = np.arange(start_x, end_x, 0.1)
Y1 = np.arange(start_y, end_y, 0.1)
Z1 = np.zeros(len(X1))
X_new = np.zeros((len(X1), 2))
for i in range(len(X1)):
X_new[i][0] = X1[i]
X_new[i][1] = Y1[i]
return X1, Y1, Z1, X_new
def make_gif(X1, Y1, Z1, x_list, y_list, q, b, c, x0, y0):
X1, Y1 = np.meshgrid(X1, Y1)
Z1 = f_mesh(X1, Y1, q, b, c)
x_list = np.delete(x_list, 0, axis=0)
y_list = np.delete(y_list, 0, axis=0)
frames = []
for i in range(1, len(x_list)):
X, Y = zip(*x_list[:i])
Z = y_list[:i]
xc = x_list[i][0]
yc = x_list[i][1]
ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 10))
cs = plt.contour(X1, Y1, Z1)
plt.suptitle('Starting point: ({}, {}) Iteration number: {} Current Point: ({}, {})'.format(x0, y0,
i, round(xc, 2), round(yc, 2)), fontsize=14, fontweight='bold')
plt.clabel(cs, inline=1, fontsize=10)
colors = ['b', 'g', 'm', 'c', 'orange']
for j in range(1, len(X)):
ax[1].annotate('', xy=(X[j], Y[j]), xytext=(X[j - 1], Y[j - 1]),
arrowprops={'arrowstyle': '->', 'color': 'r', 'lw': 1},
va='center', ha='center')
ax[1].scatter(X, Y, s=40, lw=0)
ax[1].set_xlabel('X')
ax[1].set_ylabel('Y')
ax[1].set_title('Minimizing function')
plt.savefig('img.png')
plt.close('all')
new_frame = imageio.imread('img.png')
frames.append(new_frame)
print("\r {}/{} written.".format(i, len(x_list)))
name = str(time.time())
name = name.replace('.', '')
imageio.mimsave('static/' + name + ".gif", frames)
return name
def grad_descent(q, b, c, x0, y0, eps=0.05, precision=0.0001, max_iter=200):
X_old = np.zeros((1, 2))
X_new = np.zeros((1, 2))
Y_new = np.zeros(1)
dfr = np.zeros((1, 2))
X_new[0][0] = x0
X_new[0][1] = y0
i = 0
Xs = np.zeros((1, 2))
Ys = np.zeros(1)
x, y = sym.symbols('x y')
df1 = sym.diff(f2(x, y, q, b, c), x)
df2 = sym.diff(f2(x, y, q, b, c), y)
while np.sum(abs(X_new - X_old)) > precision and max_iter > i:
Xs = np.append(Xs, X_new, axis=0)
Y_new[0] = f2(X_new[0][0], X_new[0][1], q, b, c)
Ys = np.append(Ys, Y_new, axis=0)
X_old = X_new
dfr[0][0] = df1.evalf(subs={x: X_old[0][0], y: X_old[0][1]})
dfr[0][1] = df2.evalf(subs={x: X_old[0][0], y: X_old[0][1]})
X_new = X_new - eps * dfr
i += 1
eps *= 0.99
print("Finished with {} step".format(i))
if i < max_iter:
Xs = np.append(Xs, X_new, axis=0)
Y_new[0] = f2(X_new[0][0], X_new[0][1], q, b, c)
Ys = np.append(Ys, Y_new, axis=0)
return Xs, Ys
def steepest(q, b, c, x0, y0, precision=0.0001, max_iter=200):
X_old = np.zeros((1, 2))
X_new = np.zeros((1, 2))
Y_new = np.zeros(1)
dfr = np.zeros((1, 2))
X_new[0][0] = x0
X_new[0][1] = y0
i = 0
Xs = np.zeros((1, 2))
Ys = np.zeros(1)
x, y = sym.symbols('x y')
df1 = sym.diff(f2(x, y, q, b, c), x)
df2 = sym.diff(f2(x, y, q, b, c), y)
while np.sum(abs(X_new - X_old)) > precision and max_iter > i:
Xs = np.append(Xs, X_new, axis=0)
Y_new[0] = f2(X_new[0][0], X_new[0][1], q, b, c)
Ys = | np.append(Ys, Y_new, axis=0) | numpy.append |
import os
import glob
import tensorflow as tf
import numpy as np
import argparse
import skimage.io
import MODEL2
import skimage.transform
import matplotlib.pyplot as plt
h = 224
w = 224
parser = argparse.ArgumentParser()
parser.add_argument('--input_dir',
type=str,
default='dataset/endoscope/val/img')
parser.add_argument('--gt_dir',
type=str,
default='dataset/endoscope/val/label')
parser.add_argument('--model_dir',
type=str,
default='model/multi_task')
parser.add_argument('--model_name',
type=str,
default='model99.ckpt')
parser.add_argument('--save_dir',
type=str,
default='./result/multi_task_99')
parser.add_argument('--gpu',
type=int,
default=0)
flags = parser.parse_args()
def Iou(pred, label):
h, w = pred.shape
pred = np.reshape(pred, (h * w, 1))
label = np.reshape(label, (h * w, 1))
intersection = np.sum(np.multiply(label, pred))
union = np.sum(label) + np.sum(pred)
iou = (intersection + 1e-7) /(union - intersection + 1e-7)
return iou
def precision(pred, label):
h, w = pred.shape
pred = np.reshape(pred, (h * w, 1))
label = np.reshape(label, (h * w, 1))
intersection = np.sum(np.equal(label, pred).astype(np.float32))
return intersection / (h * w)
def precision_class(pred, label):
if pred == label:
return 1.0
else:
return 0.0
def classification(output, gt):
gt_label = np.unique(gt)
group = 1
if len(gt_label) == 1:
if gt_label == 0:
group = 0
output_label = np.unique(output)
if group == 1:
if len(output_label) == 1 and output_label == 0:
return 0, group
return 1, group
else:
if len(output_label) == 1 and output_label == 0:
return 1, group
return 0, group
def sigmiod(score):
return 1 / (1 + np.exp(-1 * score))
def _int64_feature(value):
return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
def _bytes_feature(value):
return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
def main(flags):
filename = './dataset/last_fc.tfrecords'
if not os.path.exists(flags.save_dir):
os.mkdir(flags.save_dir)
writer = tf.python_io.TFRecordWriter(filename)
g = tf.Graph()
with g.as_default():
X = tf.placeholder(tf.float32, shape=[None, h, w, 3], name='X')
y = tf.placeholder(tf.float32, shape=[None, h, w, 1], name='y')
image_label = tf.placeholder(tf.float32, shape=[None, 1], name='image_label')
mode = tf.placeholder(tf.bool, name='mode')
fc3, fc2, score_dsn6_up, score_dsn5_up, score_dsn4_up, score_dsn3_up, score_dsn2_up, score_dsn1_up, upscore_fuse = MODEL2.dss_model(X, y, mode)
saver = tf.train.Saver()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
sess.run(tf.global_variables_initializer())
saver.restore(sess, os.path.join(flags.model_dir, flags.model_name))
print(os.path.join(flags.model_dir, flags.model_name))
names=os.listdir(flags.input_dir)
for name in names:
inputname=os.path.join(flags.input_dir, name)
print(inputname)
img = skimage.io.imread(inputname)
img = skimage.transform.resize(img, (h, w))
img = skimage.img_as_ubyte(img)
img = img.astype(np.float32)
inputgtname = os.path.join(flags.gt_dir, name)
print(inputgtname)
label1 = skimage.io.imread(inputgtname)
label2 = skimage.transform.resize(label1, (h, w))
label2 = skimage.img_as_ubyte(label2)
label = (label1 >= (0.5 * 255)).astype(np.float32)
label_unique = np.unique(label)
if len(label_unique) == 1 and label_unique[0] == 0:
curr_image_label = 0
else:
curr_image_label = 1
fc2_value = sess.run(fc2, feed_dict={X: | np.expand_dims(img, 0) | numpy.expand_dims |
#!/usr/bin/python
from visuals import GameWindow
import argparse
import ai2048demo
import copy
import numpy
import math
import struct
import random
import sys
import pickle
import time
import theano
import theano.tensor as T
sys.path.append('../../vi')
import vi.theano
# Directions, DO NOT MODIFY
UP = 0
DOWN = 1
LEFT = 2
RIGHT = 3
# Offsets for computing tile indices in each direction.
# DO NOT MODIFY this dictionary.
OFFSETS = { UP: ( 1, 0),
DOWN: (-1, 0),
LEFT: ( 0, 1),
RIGHT: ( 0, -1) }
def merge(line):
# Helper function that merges a single row or column in 2048
# Move all non-zero values of list to the left
nonzeros_removed = []
result = []
merged = False
for number in line:
if number != 0:
nonzeros_removed.append(number)
while len(nonzeros_removed) != len(line):
nonzeros_removed.append(0)
# Double sequental tiles if same value
for number in range(0, len(nonzeros_removed) - 1):
if nonzeros_removed[number] == nonzeros_removed[number + 1] and merged == False:
result.append(nonzeros_removed[number] * 2)
merged = True
elif nonzeros_removed[number] != nonzeros_removed[number + 1] and merged == False:
result.append(nonzeros_removed[number])
elif merged == True:
merged = False
if nonzeros_removed[-1] != 0 and merged == False:
result.append(nonzeros_removed[-1])
while len(result) != len(nonzeros_removed):
result.append(0)
return result
# https://github.com/jbutewicz/An-Introduction-to-Interactive-Programming-in-Python/blob/master/Principles%20of%20Computing%20Week%201/2048.py
# Modified for convenience.
class TwentyFortyEight:
@staticmethod
def count_line_merges(line):
merges = 0
prev = 0
counter = 0
for i in range(4):
rank = line[i]
if rank:
if prev == rank:
counter += 1
elif counter > 0:
merges += 1 + counter
counter = 0
prev = rank
if counter > 0:
merges += 1 + counter
return merges
# Class to run the game logic.
# Compute inital row dictionary to make move code cleaner
initial = {
UP : [[0,element] for element in range(4)],
DOWN : [[4 - 1, element] for element in range(4)],
LEFT : [[element, 0] for element in range(4)],
RIGHT : [[element, 4 - 1] for element in range (4)]
}
def __init__(self, state=None):
if state:
self.cells = state
else:
self.reset()
def __str__(self):
# Print a string representation of the grid for debugging.
for number in range(0, 4):
print(self.cells[number])
def can_move(self, direction):
temp = copy.deepcopy(self.cells)
result = self.move(direction, with_spawn=False)
self.cells = temp
return result
def copy_and_set_tile(self, row, col, value):
new = TwentyFortyEight(self.cells)
new.set_tile(row, col, value)
return new
def count_free(self):
return sum(cell == 0 for row in self.cells for cell in row)
def count_merges(self):
return self.count_horizontal_merges() + \
self.count_vertical_merges()
def count_horizontal_merges(self):
return (self.count_line_merges(self.cells[0]) +
self.count_line_merges(self.cells[1]) +
self.count_line_merges(self.cells[2]) +
self.count_line_merges(self.cells[3]))
def count_vertical_merges(self):
return (self.count_line_merges([self.cells[0][0], self.cells[1][0], self.cells[2][0], self.cells[3][0]]) +
self.count_line_merges([self.cells[0][1], self.cells[1][1], self.cells[2][1], self.cells[3][1]]) +
self.count_line_merges([self.cells[0][2], self.cells[1][2], self.cells[2][2], self.cells[3][2]]) +
self.count_line_merges([self.cells[0][3], self.cells[1][3], self.cells[2][3], self.cells[3][3]]))
def get_highest_tile(self):
return max(cell for row in self.cells for cell in row)
def get_tile(self, row, col):
# Return the value of the tile at position row, col.
return self.cells[row][col]
def is_game_over(self):
return not any(self.can_move(direction) for direction in [UP, DOWN, LEFT, RIGHT])
def move(self, direction, with_spawn=True):
# Move all tiles in the given direction and add
# a new tile if any tiles moved.
initial_list = self.initial[direction]
temporary_list = []
if(direction == UP):
return self.move_helper(initial_list, direction, temporary_list, with_spawn)
elif(direction == DOWN):
return self.move_helper(initial_list, direction, temporary_list, with_spawn)
elif(direction == LEFT):
return self.move_helper(initial_list, direction, temporary_list, with_spawn)
elif(direction == RIGHT):
return self.move_helper(initial_list, direction, temporary_list, with_spawn)
def move_helper(self, initial_list, direction, temporary_list, with_spawn):
# Move all columns and merge
self.cells_before = copy.deepcopy(self.cells)
for element in initial_list:
temporary_list.append(element)
for index in range(1, 4):
temporary_list.append([x + y for x, y in zip(temporary_list[-1], OFFSETS[direction])])
indices = []
for index in temporary_list:
indices.append(self.get_tile(index[0], index[1]))
merged_list = merge(indices)
for index_x, index_y in zip(merged_list, temporary_list):
self.set_tile(index_y[0], index_y[1], index_x)
temporary_list = []
if self.cells_before != self.cells:
if with_spawn:
self.new_tile()
return True
else:
return False
def new_tile(self):
# Create a new tile in a randomly selected empty
# square. The tile should be 2 90% of the time and
# 4 10% of the time.
available_positions = []
for row in range(4):
for col in range(4):
if self.cells[row][col] == 0:
available_positions.append([row, col])
if not available_positions:
return False
else:
random_tile = random.choice(available_positions)
weighted_choices = [(2, 9), (4, 1)]
population = [val for val, cnt in weighted_choices for i in range(cnt)]
tile = random.choice(population)
self.set_tile(random_tile[0],random_tile[1], tile)
return True
def reset(self):
# Reset the game so the grid is empty.
self.cells = [[0 for col in range(4)] for row in range(4)]
self.cells_before = copy.deepcopy(self.cells)
def set_tile(self, row, col, value):
# Set the tile at position row, col to have the given value.
self.cells[row][col] = value
def undo_move(self):
self.cells = self.cells_before
def generate_training_data(representation):
game = TwentyFortyEight()
game.new_tile()
xdata = []
ydata = []
while not game.is_game_over():
num_free = game.count_free()
moves_scored = sorted(((score_move(game, representation, move) - num_free, move) for move in range(4)), reverse=True)
best_move = moves_scored[0][1]
# Only use as training example if delta is positive and move is scored better than any other move:
if moves_scored[0][0] > 0 and any(moves_scored[i][0] != moves_scored[0][0] for i in range(1, 4)):
x = transform_state(game, representation)
y = best_move
xdata.append(x)
ydata.append(y)
game.move(best_move)
return game.get_highest_tile(), xdata, ydata
def score_move(game, representation, move):
if game.move(move, with_spawn=False):
score = game.count_free()
game.undo_move()
return score
else:
return -1
def play_ann_game(representation, predict_function):
game = TwentyFortyEight()
game.new_tile()
while not game.is_game_over():
x = numpy.asarray(transform_state(game, representation))
move_probabilities = predict_function(x.reshape(1, x.shape[0]))[0]
move_probabilities_sorted = sorted(((probability, move) for (move, probability) in enumerate(move_probabilities)), reverse=True)
# Select the first valid move ranked by probability:
for probability, move in move_probabilities_sorted:
if game.move(move):
break
t = game.get_highest_tile()
print(t)
return t
def play_ai_game(representation):
game = TwentyFortyEight()
game.new_tile()
while not game.is_game_over():
game.move(max((score_move(game, representation, move), move) for move in range(4))[1])
return game.get_highest_tile()
def play_random_game():
game = TwentyFortyEight()
game.new_tile()
while not game.is_game_over():
game.move(random.choice([UP, DOWN, LEFT, RIGHT]))
return game.get_highest_tile()
def transform_state(game, representation):
if not representation:
# Representation A:
return [ TwentyFortyEight.count_line_merges(game.cells[0]),
TwentyFortyEight.count_line_merges(game.cells[1]),
TwentyFortyEight.count_line_merges(game.cells[2]),
TwentyFortyEight.count_line_merges(game.cells[3]),
TwentyFortyEight.count_line_merges([game.cells[0][0], game.cells[1][0], game.cells[2][0], game.cells[3][0]]),
TwentyFortyEight.count_line_merges([game.cells[0][1], game.cells[1][1], game.cells[2][1], game.cells[3][1]]),
TwentyFortyEight.count_line_merges([game.cells[0][2], game.cells[1][2], game.cells[2][2], game.cells[3][2]]),
TwentyFortyEight.count_line_merges([game.cells[0][3], game.cells[1][3], game.cells[2][3], game.cells[3][3]]) ]
else:
# Representation B:
values = [ game.cells[row][column] for row in range(4) for column in range(4) ]
unique_nonzero = sorted(list(set(values) - set([0])))
return [ (unique_nonzero.index(value) + 1 if value in unique_nonzero else 0) for value in values ]
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--A', action='store_true')
parser.add_argument('--B', action='store_true')
parser.add_argument('--L1', type=float)
parser.add_argument('--L2', type=float)
parser.add_argument('--ai', action='store_true')
parser.add_argument('--benchmark', type=int)
parser.add_argument('--compare', type=int)
parser.add_argument('--data_a', default='training_data_a.pkl')
parser.add_argument('--data_b', default='training_data_b.pkl')
parser.add_argument('--demo', action='store_true')
parser.add_argument('--dropout', type=float)
parser.add_argument('--epochs', type=int, default=100)
parser.add_argument('--generate', type=int)
parser.add_argument('--hidden_function', default='relu')
parser.add_argument('--hidden_layers', nargs='*')
parser.add_argument('--learning_rate', type=float, default=0.08)
parser.add_argument('--max_time', type=int)
parser.add_argument('--minibatch_size', type=int, default=40)
parser.add_argument('--model_a', default='model_a.pkl')
parser.add_argument('--model_b', default='model_b.pkl')
parser.add_argument('--output_directory', default='../data')
parser.add_argument('--runs', action='store_true')
parser.add_argument('--seed', type=int)
parser.add_argument('--training_ratio', type=float)
args = parser.parse_args()
if not args.A and not args.B and not args.compare:
print('A or B representation must be chosen!')
sys.exit(-1)
print(args)
random.seed(42)
numpy.random.seed(random.randint(0, 2 ** 30))
if args.ai:
if args.benchmark:
La = list(play_ai_game(args.B) for _ in range(args.benchmark))
print('mean: {} std: {}'.format(numpy.mean(La), numpy.std(La)))
else:
Lr = list(play_random_game() for _ in range(50))
La = list(play_ai_game(args.B) for _ in range(50))
print('random play: {}'.format(Lr))
print('ann play: {}'.format(La))
print(ai2048demo.welch(Lr, La))
elif args.benchmark:
network = pickle.load(open(args.model_a if args.A else args.model_b, 'rb'))
predict_function = theano.function(
inputs=[network.inputs],
outputs=network.layers[-1].testing_outputs,
allow_input_downcast=True)
La = [ play_ann_game(args.B, predict_function) for _ in range(args.benchmark) ]
print('mean: {} std: {}'.format(numpy.mean(La), numpy.std(La)))
elif args.generate:
training_data = []
training_labels = []
for i in range(args.generate):
top_tile, x, y = generate_training_data(args.B)
training_data.extend(x)
training_labels.extend(y)
print('{}/{} ({:.2f}%)'.format(i + 1, args.generate, 100.0 * (i + 1) / args.generate))
print('{} examples generated from {} games'.format(len(training_data), args.generate))
training_examples = list(zip(training_data, training_labels))
random.shuffle(training_examples)
training_data[:], training_labels[:] = zip(*training_examples)
with open(args.data_a if args.A else args.data_b, 'wb') as training_data_file:
pickle.dump((training_data, training_labels), training_data_file)
elif args.compare:
import scipy.stats
network_a = pickle.load(open(args.model_a, 'rb'))
network_b = pickle.load(open(args.model_b, 'rb'))
predict_function_a = theano.function(
inputs=[network_a.inputs],
outputs=network_a.layers[-1].testing_outputs,
allow_input_downcast=True)
predict_function_b = theano.function(
inputs=[network_b.inputs],
outputs=network_b.layers[-1].testing_outputs,
allow_input_downcast=True)
La_a = [ play_ann_game(False, predict_function_a) for _ in range(args.compare) ]
La_b = [ play_ann_game(True, predict_function_b) for _ in range(args.compare) ]
statistic, pvalue = scipy.stats.ttest_ind(La_a, La_b, equal_var=False)
print('A mean: {} A std: {}'.format(numpy.mean(La_a), numpy.std(La_a)))
print('B mean: {} B std: {}'.format(numpy.mean(La_b), numpy.std(La_b)))
print('statistic = {:f} pvalue = {:f}'.format(statistic, pvalue))
elif args.demo:
network = pickle.load(open(args.model_a if args.A else args.model_b, 'rb'))
predict_function = theano.function(
inputs=[network.inputs],
outputs=network.layers[-1].testing_outputs,
allow_input_downcast=True)
La = []
for _ in range(50):
game = TwentyFortyEight()
game.new_tile()
while not game.is_game_over():
x = numpy.asarray(transform_state(game, args.B))
move_probabilities = predict_function(x.reshape(1, x.shape[0]))[0]
move_probabilities_sorted = sorted(((probability, move) for (move, probability) in enumerate(move_probabilities)), reverse=True)
# Select the first valid move ranked by probability:
for probability, move in move_probabilities_sorted:
if game.move(move):
break
t = game.get_highest_tile()
print(t)
La.append(t)
Lr = list(play_random_game() for _ in range(50))
print('random play: {}'.format(Lr))
print('ann play: {}'.format(La))
print(ai2048demo.welch(Lr, La))
else:
def epoch_status_function(time, epoch, average_loss, testing_error, is_best):
if is_best:
with open(args.model_a if args.A else args.model_b, 'wb') as model_file:
pickle.dump(network, model_file)
print("Time: {:7.2f} sec, Epoch: {:4d}, Average loss: {:.5f}, Testing error: {:.5f}%".format(
time, epoch, average_loss, testing_error * 100.0))
x_data, y_data = pickle.load(open(args.data_a if args.A else args.data_b, 'rb'))
#x_data, y_data = shuffle(x_data, y_data, random_state=0)
num_training_examples = int(math.ceil(args.training_ratio * len(x_data))) \
if args.training_ratio else len(x_data)
input_size = len(x_data[0])
layer_sizes = [input_size] + list(map(int, args.hidden_layers or [])) + [4]
print("Creating shared Theano dataset variables...")
training_dataset = vi.theano.TheanoDataSet(
theano.shared( | numpy.asarray(x_data[:num_training_examples], dtype=theano.config.floatX) | numpy.asarray |
# <NAME>
# 3/18/2019
# General object to run empirical sr actflow process
# For group-level/cross-subject analyses
import numpy as np
import os
import multiprocessing as mp
import scipy.stats as stats
import nibabel as nib
import os
os.environ['OMP_NUM_THREADS'] = str(1)
import sklearn
from scipy import signal
import h5py
import sys
sys.path.append('glmScripts/')
import glmScripts.taskGLMPipeline_v2 as tgp
import sys
import pandas as pd
import pathlib
import calculateFC as fc
import tools
# Using final partition
networkdef = np.loadtxt('/home/ti61/f_mc1689_1/NetworkDiversity/data/network_partition.txt')
networkorder = np.asarray(sorted(range(len(networkdef)), key=lambda k: networkdef[k]))
networkorder.shape = (len(networkorder),1)
# network mappings for final partition set
networkmappings = {'fpn':7, 'vis1':1, 'vis2':2, 'smn':3, 'aud':8, 'lan':6, 'dan':5, 'con':4, 'dmn':9,
'pmulti':10, 'none1':11, 'none2':12}
networks = networkmappings.keys()
## General parameters/variables
nParcels = 360
class Model():
"""
Class to perform empirical actflow for a given subject (stimulus-to-response)
"""
def __init__(self,projectdir='/home/ti61/f_mc1689_1/SRActFlow/',ruletype='12',n_hiddenregions=10,randomize=False,scratchfcdir=None):
"""
instantiate:
indices for condition types
indices for specific condition instances
betas
"""
#### Set up basic model parameters
self.projectdir = projectdir
# Excluding 084
self.subjNums = ['013','014','016','017','018','021','023','024','026','027','028','030','031','032','033',
'034','035','037','038','039','040','041','042','043','045','046','047','048','049','050',
'053','055','056','057','058','062','063','066','067','068','069','070','072','074','075',
'076','077','081','085','086','087','088','090','092','093','094','095','097','098','099',
'101','102','103','104','105','106','108','109','110','111','112','114','115','117','119',
'120','121','122','123','124','125','126','127','128','129','130','131','132','134','135',
'136','137','138','139','140','141']
self.inputtypes = ['RED','VERTICAL','CONSTANT','HIGH']
self.ruletype = ruletype
#### Load in atlas
glasserfile2 = projectdir + 'data/Q1-Q6_RelatedParcellation210.LR.CorticalAreas_dil_Colors.32k_fs_RL.dlabel.nii'
glasser2 = nib.load(glasserfile2).get_data()
glasser2 = np.squeeze(glasser2)
self.glasser2 = glasser2
####
# Define hidden units
if n_hiddenregions!=None:
#######################################
#### Select hidden layer regions
hiddendir = projectdir + 'data/results/MAIN/RSA/'
hiddenregions = np.loadtxt(hiddendir + 'RSA_Similarity_SortedRegions2.txt',delimiter=',')
#######################################
#### Output directory
if randomize:
print("Constructing model with", n_hiddenregions, "randomly selected hidden regions")
fcdir = scratchfcdir
#### Necessary to optimize amarel
pathlib.Path(fcdir).mkdir(parents=True, exist_ok=True) # Make sure directory exists
hiddenregions = np.random.choice(hiddenregions,size=n_hiddenregions,replace=False)
else:
print("Constructing model with", n_hiddenregions, "hidden regions")
fcdir = projectdir + 'data/results/MAIN/fc/LayerToLayerFC_' + str(n_hiddenregions) + 'Hidden/'
pathlib.Path(fcdir).mkdir(parents=True, exist_ok=True) # Make sure directory exists
# Select hidden layer
if n_hiddenregions < 0:
hiddenregions = hiddenregions[n_hiddenregions:]
else:
hiddenregions = hiddenregions[:n_hiddenregions]
## Set object attributes
self.n_hiddenregions = n_hiddenregions
self.hiddenregions = np.squeeze(hiddenregions)
self.fcdir = fcdir
self.hidden = True # Set this variable to true - indicates to run sr simulations with a hidden layer
#### identify hidden region vertex indices
hidden_ind = []
for roi in hiddenregions:
hidden_ind.extend(np.where(self.glasser2==roi+1)[0])
self.hidden_ind = hidden_ind
else:
print("Constructing model with NO hidden layers")
fcdir = projectdir + 'data/results/MAIN/fc/LayerToLayerFC_NoHidden/'
pathlib.Path(fcdir).mkdir(parents=True, exist_ok=True) # Make sure directory exists
self.hidden = False # Set this variable to true - indicates to run sr simulations with a hidden layer
self.fcdir = fcdir
self.hiddenregions = None
self.n_hiddenregions = n_hiddenregions
####
# Define task rule (input) layer
ruledir = self.projectdir + 'data/results/MAIN/RuleDecoding/'
if ruletype=='12':
rule_regions = np.loadtxt(ruledir + self.ruletype + 'Rule_Regions.csv',delimiter=',')
elif ruletype=='fpn':
rule_regions = []
rule_regions.extend(np.where(networkdef==networkmappings['fpn'])[0])
rule_regions = np.asarray(rule_regions)
elif ruletype=='nounimodal':
allrule_regions = np.loadtxt(ruledir + '12Rule_Regions.csv',delimiter=',')
unimodal_nets = ['vis1','aud']
unimodal_regions = []
for net in unimodal_nets:
unimodal_regions.extend(np.where(networkdef==networkmappings[net])[0])
# only include regions that are in allrule_regions but also NOT in unimodal_regions
rule_regions = []
for roi in allrule_regions:
if roi in unimodal_regions:
continue
else:
rule_regions.append(roi)
rule_regions = np.asarray(rule_regions)
rule_ind = []
for roi in rule_regions:
rule_ind.extend(np.where(self.glasser2==roi+1)[0])
self.rule_ind = rule_ind
####
# Define motor regions
# Set indices for layer-by-layer vertices
targetdir = projectdir + 'data/results/MAIN/MotorResponseDecoding/'
motor_resp_regions_LH = np.loadtxt(targetdir + 'MotorResponseRegions_LH.csv',delimiter=',')
motor_resp_regions_RH = np.loadtxt(targetdir + 'MotorResponseRegions_RH.csv',delimiter=',')
targetROIs = np.hstack((motor_resp_regions_LH,motor_resp_regions_RH))
# Define all motor_ind
motor_ind = []
for roi in targetROIs:
roi_ind = np.where(glasser2==roi+1)[0]
motor_ind.extend(roi_ind)
motor_ind = np.asarray(motor_ind).copy()
self.motor_ind = motor_ind
#### override -- only pick the motor parcel with the greatest response decoding
motor_ind_lh = []
for roi in motor_resp_regions_LH:
# only include left hand responses in the right hemisphere
if roi>=180:
roi_ind = np.where(glasser2==roi+1)[0]
motor_ind_lh.extend(roi_ind)
motor_ind_rh = []
for roi in motor_resp_regions_RH:
# only include left hand responses in the right hemisphere
if roi<180:
roi_ind = np.where(glasser2==roi+1)[0]
motor_ind_rh.extend(roi_ind)
#
motor_ind_rh = np.asarray(motor_ind_rh).copy()
motor_ind_lh = np.asarray(motor_ind_lh).copy()
self.motor_ind_rh = motor_ind_rh
self.motor_ind_lh = motor_ind_lh
#### Load model task set
filename= projectdir + 'data/results/MAIN/EmpiricalSRActFlow_AllTrialKeys_15stims_v3.csv' # Great
self.trial_metadata = pd.read_csv(filename)
def computeGroupFC(self,n_components=500,nproc='max'):
"""
Function that wraps _computeSubjFC() to compute FC for all subjs, and computes averaged groupFC
"""
if nproc=='max':
nproc=mp.cpu_count()
inputs = []
for subj in self.subjNums:
inputs.append((subj,n_components))
pool = mp.Pool(processes=nproc)
if self.hidden:
pool.starmap_async(self._computeSubjFC,inputs)
else:
pool.starmap_async(self._computeSubjFC_NoHidden,inputs)
pool.close()
pool.join()
#### Compute group FC
for inputtype in self.inputtypes:
if self.hidden:
fc.computeGroupFC(inputtype,self.fcdir)
else:
fc.computeGroupFC_NoHidden(inputtype,self.fcdir)
if self.hidden:
fc.computeGroupFC(self.ruletype,self.fcdir)
else:
fc.computeGroupFC_NoHidden(self.ruletype,self.fcdir)
def loadRealMotorResponseActivations(self,vertexmasks=True):
#### Load motor response activations localized in output vertices only (for faster loading)
if vertexmasks:
print('Load real motor responses in output vertices')
self.data_task_rh, self.data_task_lh = tools.loadMotorResponsesOutputMask()
else:
print('Load real motor responses in output parcels -- inefficient since need to load all vertices first')
data_task_rh = []
data_task_lh = []
for subj in self.subjNums:
tmp_rh = tools.loadMotorResponses(subj,hand='Right')
tmp_lh = tools.loadMotorResponses(subj,hand='Left')
data_task_rh.append(tmp_rh[self.motor_ind_rh,:].copy().T)
data_task_lh.append(tmp_lh[self.motor_ind_lh,:].copy().T)
self.data_task_rh = np.asarray(data_task_rh).T
self.data_task_lh = np.asarray(data_task_lh).T
def loadModelFC(self):
if self.hidden:
print('Load Model FC weights')
fcdir = self.fcdir
self.fc_input2hidden = {}
self.eig_input2hidden = {}
for inputtype in ['VERTICAL','RED','HIGH','CONSTANT']:
self.fc_input2hidden[inputtype], self.eig_input2hidden[inputtype] = tools.loadGroupActFlowFC(inputtype,fcdir)
# Load rule to hidden
self.fc_12rule2hidden, self.eig_12rule2hidden = tools.loadGroupActFlowFC(self.ruletype,fcdir)
# Load hidden to motor resp mappings
self.fc_hidden2motorresp, self.eig_hidden2motorresp = tools.loadGroupActFlowFC('hidden2out',fcdir)
else:
print('Load Model FC weights -- No hidden layer')
fcdir = self.fcdir
self.fc_input2output = {}
self.eig_input2output = {}
for inputtype in ['VERTICAL','RED','HIGH','CONSTANT']:
self.fc_input2output[inputtype], self.eig_input2output[inputtype] = tools.loadGroupActFlowFC_NoHidden(inputtype,fcdir)
# Load rule to hidden
self.fc_12rule2output, self.eig_12rule2output = tools.loadGroupActFlowFC_NoHidden('12',fcdir)
def simulateGroupActFlow(self,thresh=0,nproc='max',vertexmasks=True):
"""
Simulate group level actflow (all subject simulations)
"""
if nproc=='max':
nproc=mp.cpu_count()
inputs = []
for subj in self.subjNums:
inputs.append((subj,thresh))
if nproc == 1:
results = []
for input1 in inputs:
results.append(self._simulateSubjActFlow(input1[0],input1[1]))
else:
pool = mp.Pool(processes=nproc)
results = pool.starmap_async(self._simulateSubjActFlow,inputs).get()
pool.close()
pool.join()
actflow_predictions = np.zeros((len(self.subjNums),len(self.motor_ind),4))
#actflow_predictions_noReLU = np.zeros((len(self.subjNums),len(self.motor_ind),4))
scount = 0
for result in results:
# actflow_predictions[scount,:,:] = result[0]
# actflow_predictions_noReLU[scount,:,:] = result[1]
actflow_predictions[scount,:,:] = result
scount += 1
## Reformat to fit shape of actual data array
actflow_rh = np.zeros((len(self.glasser2),2,len(self.subjNums)))
actflow_lh = np.zeros((len(self.glasser2),2,len(self.subjNums)))
for scount in range(len(self.subjNums)):
# RMID
actflow_rh[self.motor_ind,0,scount] = actflow_predictions[scount,:,2]
# RIND
actflow_rh[self.motor_ind,1,scount] = actflow_predictions[scount,:,3]
# LMID
actflow_lh[self.motor_ind,0,scount] = actflow_predictions[scount,:,0]
# LIND
actflow_lh[self.motor_ind,1,scount] = actflow_predictions[scount,:,1]
#### Now save out only relevant output mask vertices
if vertexmasks:
tmp = np.squeeze(nib.load(self.projectdir + 'data/results/MAIN/MotorRegionsMasksPerSubj/sractflow_smn_outputRH_mask.dscalar.nii').get_data())
rh_ind = np.where(tmp==True)[0]
actflow_rh = actflow_rh[rh_ind,:,:]
tmp = np.squeeze(nib.load(self.projectdir + 'data/results/MAIN/MotorRegionsMasksPerSubj/sractflow_smn_outputLH_mask.dscalar.nii').get_data())
lh_ind = np.where(tmp==True)[0]
actflow_lh = actflow_lh[lh_ind,:,:].copy()
else:
actflow_rh = actflow_rh[self.motor_ind_rh,:,:].copy()
actflow_lh = actflow_lh[self.motor_ind_lh,:,:].copy()
return actflow_rh, actflow_lh
def actflowDecoding(self,trainset,testset,outputfile,
nbootstraps=1000,featsel=False,nproc='max',null=False,verbose=True):
if nproc=='max':
nproc=mp.cpu_count()
# Decoding
for i in range(nbootstraps):
distances_baseline = np.zeros((1,len(self.subjNums)*2)) # subjs * nlabels
distances_baseline[0,:],rmatch,rmismatch, confusion_mats = tools.actflowDecodings(testset,trainset,
effects=True, featsel=featsel,confusion=True,permutation=null,
ncvs=1, nproc=nproc)
##### Save out and append file
# Open/create file
filetxt = open(outputfile,"a+")
# Write out to file
print(np.mean(distances_baseline),file=filetxt)
# Close file
filetxt.close()
if i%100==0 and verbose==True:
print('Permutation', i)
print('\tDecoding accuracy:', np.mean(distances_baseline), '| R-match:', np.mean(rmatch), '| R-mismatch:', np.mean(rmismatch))
def extractSubjActivations(self, subj, df_trials):
"""
extract activations for a sample subject, including motor response
"""
## Set up data parameters
X = tgp.loadTaskTiming(subj,'ALL')
self.stimIndex = np.asarray(X['stimIndex'])
self.stimCond = np.asarray(X['stimCond'])
datadir = self.projectdir + 'data/postProcessing/hcpPostProcCiric/'
h5f = h5py.File(datadir + subj + '_glmOutput_data.h5','r')
self.betas = h5f['taskRegression/ALL_24pXaCompCorXVolterra_taskReg_betas_canonical'][:].copy()
h5f.close()
## Set up task parameters
self.logicRules = ['BOTH', 'NOTBOTH', 'EITHER', 'NEITHER']
self.sensoryRules = ['RED', 'VERTICAL', 'HIGH', 'CONSTANT']
self.motorRules = ['LMID', 'LIND', 'RMID', 'RIND']
self.colorStim = ['RED', 'BLUE']
self.oriStim = ['VERTICAL', 'HORIZONTAL']
self.pitchStim = ['HIGH', 'LOW']
self.constantStim = ['CONSTANT','ALARM']
# Begin extraction for specific trials
n_trials = len(df_trials)
stimData = np.zeros((n_trials,self.betas.shape[0]))
logicRuleData = np.zeros((n_trials,self.betas.shape[0]))
sensoryRuleData = np.zeros((n_trials,self.betas.shape[0]))
motorRuleData = np.zeros((n_trials,self.betas.shape[0]))
respData = np.zeros((n_trials,self.betas.shape[0]))
sensoryRuleIndices = []
motorRespAll = []
for trial in range(n_trials):
logicRule = df_trials.iloc[trial].logicRule
sensoryRule = df_trials.iloc[trial].sensoryRule
motorRule = df_trials.iloc[trial].motorRule
motorResp = df_trials.iloc[trial].motorResp
stim1 = df_trials.iloc[trial].stim1
stim2 = df_trials.iloc[trial].stim2
# if verbose:
# print 'Running actflow predictions for:', logicRule, sensoryRule, motorRule, 'task'
logicKey = 'RuleLogic_' + logicRule
sensoryKey = 'RuleSensory_' + sensoryRule
motorKey = 'RuleMotor_' + motorRule
stimKey = 'Stim_' + stim1 + stim2
motorResp = solveInputs(logicRule, sensoryRule, motorRule, stim1, stim2, printTask=False)
respKey = 'Response_' + motorResp
stimKey_ind = np.where(self.stimCond==stimKey)[0]
logicRule_ind = np.where(self.stimCond==logicKey)[0]
sensoryRule_ind = np.where(self.stimCond==sensoryKey)[0]
motorRule_ind = np.where(self.stimCond==motorKey)[0]
respKey_ind = np.where(self.stimCond==respKey)[0]
stimData[trial,:] = np.real(self.betas[:,stimKey_ind].copy()[:,0])
logicRuleData[trial,:] = np.real(self.betas[:,logicRule_ind].copy()[:,0])
sensoryRuleData[trial,:] = np.real(self.betas[:,sensoryRule_ind].copy()[:,0])
motorRuleData[trial,:] = np.real(self.betas[:,motorRule_ind].copy()[:,0])
respData[trial,:] = np.real(self.betas[:,respKey_ind].copy()[:,0])
motorRespAll.append(motorResp)
sensoryRuleIndices.append(sensoryRule)
self.motorRespAll = motorRespAll
self.stimData = stimData
self.logicRuleData = logicRuleData
self.sensoryRuleData = sensoryRuleData
self.motorRuleData = motorRuleData
self.respData = respData
self.sensoryRuleIndices = sensoryRuleIndices
def extractSubjHiddenRSMActivations(self, subj):
"""
extract activations for a sample subject, including motor response
"""
## Set up data parameters
X = tgp.loadTaskTiming(subj,'ALL')
self.stimIndex = np.asarray(X['stimIndex'])
self.stimCond = np.asarray(X['stimCond'])
datadir = self.projectdir + 'data/postProcessing/hcpPostProcCiric/'
h5f = h5py.File(datadir + subj + '_glmOutput_data.h5','r')
self.betas = h5f['taskRegression/ALL_24pXaCompCorXVolterra_taskReg_betas_canonical'][:].copy()
h5f.close()
## Set up task parameters
self.logicRules = ['BOTH', 'NOTBOTH', 'EITHER', 'NEITHER']
self.sensoryRules = ['RED', 'VERTICAL', 'HIGH', 'CONSTANT']
self.motorRules = ['LMID', 'LIND', 'RMID', 'RIND']
self.colorStim = ['RED', 'BLUE']
self.oriStim = ['VERTICAL', 'HORIZONTAL']
self.pitchStim = ['HIGH', 'LOW']
self.constantStim = ['CONSTANT','ALARM']
total_conds = 28 # 12 rules + 16 stimulus pairings
rsm_activations = np.zeros((28,self.betas.shape[0]))
labels = []
condcount = 0
##
# START
for cond in self.logicRules:
labels.append(cond)
key = 'RuleLogic_' + cond
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
for cond in self.sensoryRules:
labels.append(cond)
key = 'RuleSensory_' + cond
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
for cond in self.motorRules:
labels.append(cond)
key = 'RuleMotor_' + cond
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
# This is nested for loop since stimuli come in pairs
for cond1 in self.colorStim:
for cond2 in self.colorStim:
labels.append(cond1 + cond2)
key = 'Stim_' + cond1 + cond2
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
for cond1 in self.oriStim:
for cond2 in self.oriStim:
labels.append(cond1 + cond2)
key = 'Stim_' + cond1 + cond2
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
for cond1 in self.pitchStim:
for cond2 in self.pitchStim:
labels.append(cond1 + cond2)
key = 'Stim_' + cond1 + cond2
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
for cond1 in self.constantStim:
for cond2 in self.constantStim:
labels.append(cond1 + cond2)
key = 'Stim_' + cond1 + cond2
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
return rsm_activations, labels
def generateHiddenUnitRSMPredictions(self,thresh=0,n_hiddenregions=10,filename='',verbose=False):
"""
Run all predictions for all 64 tasks
"""
hidden_ind = self.hidden_ind
rule_ind = self.rule_ind
all_actflow_unthresh = []
all_actflow_thresh = []
all_true_activity = []
for subj in self.subjNums:
print('Predicting hidden layer activations for subject', subj)
rsm_activations, labels = self.extractSubjHiddenRSMActivations(subj)
tmp_actflow_unthresh = []
tmp_actflow_thresh = []
tmp_true_activity = []
labelcount = 0
for label in labels:
# Dissociate sensory rules from sensory stimuli since stimuli have two stimulus words (e.g., 'REDRED')
if label in ['BOTH', 'NOTBOTH', 'EITHER', 'NEITHER', 'RED', 'VERTICAL', 'HIGH', 'CONSTANT', 'LMID', 'LIND', 'RMID', 'RIND']:
input_units = 'rule'
if label in ['REDRED', 'REDBLUE', 'BLUERED', 'BLUEBLUE']:
input_units = 'RED' # specify sensory rules for sensory activations
if label in ['VERTICALVERTICAL', 'VERTICALHORIZONTAL', 'HORIZONTALVERTICAL', 'HORIZONTALHORIZONTAL']:
input_units = 'VERTICAL' # this is the sensory rule
if label in ['HIGHHIGH', 'HIGHLOW', 'LOWHIGH', 'LOWLOW']:
input_units = 'HIGH'
if label in ['CONSTANTCONSTANT', 'CONSTANTALARM', 'ALARMCONSTANT', 'ALARMALARM']:
input_units = 'CONSTANT'
if input_units!='rule':
input_ind = self._getStimIndices(input_units) # Identify the vertices for stimulus layer of the ANN
unique_input_ind = np.where(np.in1d(input_ind,hidden_ind)==False)[0]
fc = self.fc_input2hidden[input_units]
pc_act = np.matmul(rsm_activations[labelcount,:][unique_input_ind],self.eig_input2hidden[input_units].T)
# Unthresholded actflow
actflow_unthresh = np.matmul(pc_act,fc)
# Thresholded actflow
actflow_thresh = np.multiply(actflow_unthresh,actflow_unthresh>thresh)
if input_units=='rule':
unique_input_ind = np.where(np.in1d(rule_ind,hidden_ind)==False)[0]
fc = self.fc_12rule2hidden
pc_act = np.matmul(rsm_activations[labelcount,:][unique_input_ind],self.eig_12rule2hidden.T)
# Unthresholded actflow
actflow_unthresh = np.matmul(pc_act,fc)
# Thresholded actflow
actflow_thresh = np.multiply(actflow_unthresh,actflow_unthresh>thresh)
tmp_actflow_unthresh.append(actflow_unthresh)
tmp_actflow_thresh.append(actflow_thresh)
tmp_true_activity.append(np.squeeze(rsm_activations[labelcount,hidden_ind]))
labelcount += 1
# Compute subject-specific predicted activations for each condition
all_actflow_unthresh.append(np.asarray(tmp_actflow_unthresh))
all_actflow_thresh.append(np.asarray(tmp_actflow_thresh))
all_true_activity.append(np.asarray(tmp_true_activity))
np.savetxt(filename + '.txt', labels, fmt='%s')
h5f = h5py.File(filename + '.h5','a')
try:
h5f.create_dataset('actflow_unthresh',data=all_actflow_unthresh)
h5f.create_dataset('actflow_thresh',data=all_actflow_thresh)
h5f.create_dataset('true_activity',data=all_true_activity)
except:
del h5f['actflow_unthresh'], h5f['actflow_thresh'], h5f['true_activity']
h5f.create_dataset('actflow_unthresh',data=all_actflow_unthresh)
h5f.create_dataset('actflow_thresh',data=all_actflow_thresh)
h5f.create_dataset('true_activity',data=all_true_activity)
h5f.close()
def generateInputControlDecoding(self,n_hiddenregions=10,verbose=False):
"""
Run all predictions for all 64 tasks
"""
hidden_ind = self.hidden_ind
rule_ind = self.rule_ind
# Also exclude smn indices
smn_rois = np.where(networkdef==networkmappings['smn'])[0]
smn_ind = []
for roi in smn_rois:
smn_ind.extend(np.where(self.glasser2==roi+1)[0])
smn_ind = np.asarray(smn_ind)
target_vertices = self.fc_hidden2motorresp.shape[1]
actflow = np.zeros((target_vertices,4)) #LMID, LIND, RMID, rIND -- 4 cols in 3rd dim for each sensory rule
input_activations_lmid = []
input_activations_lind = []
input_activations_rmid = []
input_activations_rind = []
all_input_ind = []
for sensoryRule in self.sensoryRules:
input_ind = self._getStimIndices(sensoryRule) # Identify the vertices for the stimulus layer of the ANN
all_input_ind.extend(input_ind)
all_input_ind = np.asarray(all_input_ind)
#### Input activations
unique_input_ind = np.where(np.in1d(all_input_ind,hidden_ind)==False)[0]
unique_input_ind = np.where(np.in1d(unique_input_ind,smn_ind)==False)[0]
input_act = self.stimData[:,:][:,unique_input_ind]
#### 12 rule activations
unique_input_ind = np.where(np.in1d(rule_ind,hidden_ind)==False)[0]
unique_input_ind = np.where(np.in1d(unique_input_ind,smn_ind)==False)[0]
rule_composition = self.logicRuleData[:,unique_input_ind] + self.sensoryRuleData[:,unique_input_ind] + self.motorRuleData[:,unique_input_ind]
#rule_act = self.logicRuleData[:,:][:,unique_input_ind]
##### Concatenate input activations
input_activations = np.hstack((input_act,rule_composition))
## Apply threshold
input_activations = np.multiply(input_act,input_act>0)
#### Average into 4 different responses
respIndex = np.asarray(self.motorRespAll)
# LMID
ind = np.where(respIndex=='LMID')[0]
if len(ind)!=0:
input_activations_lmid.append(np.sum(input_activations[ind,:],axis=0))
# LIND
ind = np.where(respIndex=='LIND')[0]
if len(ind)!=0:
input_activations_lind.append(np.sum(input_activations[ind,:],axis=0))
# RMID
ind = np.where(respIndex=='RMID')[0]
if len(ind)!=0:
input_activations_rmid.append(np.sum(input_activations[ind,:],axis=0))
# RIND
ind = np.where(respIndex=='RIND')[0]
if len(ind)!=0:
input_activations_rind.append(np.sum(input_activations[ind,:],axis=0))
return input_activations_lmid, input_activations_lind, input_activations_rmid, input_activations_rind
def generateActFlowPredictions_12Rule_PCFC(self,thresh=0,n_hiddenregions=10,verbose=False):
"""
Run all predictions for all 64 tasks
"""
hidden_ind = self.hidden_ind
rule_ind = self.rule_ind
target_vertices = self.fc_hidden2motorresp.shape[1]
actflow = np.zeros((target_vertices,4)) #LMID, LIND, RMID, rIND -- 4 cols in 3rd dim for each sensory rule
sensecount = 0
for sensoryRule in self.sensoryRules:
sensoryIndices = np.where(np.asarray(self.sensoryRuleIndices)==sensoryRule)[0]
input_ind = self._getStimIndices(sensoryRule) # Identify the vertices for stimulus layer of the ANN
# Run activity flow
#### Input to hidden regions
# first identify non-overlapping indices
unique_input_ind = np.where(np.in1d(input_ind,hidden_ind)==False)[0]
fc = self.fc_input2hidden[sensoryRule]
pc_act = np.matmul(self.stimData[sensoryIndices,:][:,unique_input_ind],self.eig_input2hidden[sensoryRule].T)
actflow_stim = np.matmul(pc_act,fc)
#### Rule compositions
#### (12rule) to hidden regions
unique_input_ind = np.where(np.in1d(rule_ind,hidden_ind)==False)[0]
rule_composition = self.logicRuleData[sensoryIndices,:][:,unique_input_ind] + self.sensoryRuleData[sensoryIndices,:][:,unique_input_ind] + self.motorRuleData[sensoryIndices,:][:,unique_input_ind]
# first identify non-overlapping indices
fc = self.fc_12rule2hidden
pc_act = np.matmul(rule_composition,self.eig_12rule2hidden.T)
actflow_taskrules = np.matmul(pc_act,fc)
hiddenlayer_composition = actflow_taskrules + actflow_stim
# Apply a threshold if there is one
if thresh==None:
pass
else:
hiddenlayer_composition = np.multiply(hiddenlayer_composition,hiddenlayer_composition>thresh)
#t, p = stats.ttest_1samp(hiddenlayer_composition,0,axis=0) # Trials x Vertices
#p[t>0] = p[t>0]/2.0
#p[t<0] = 1.0 - p[t<0]/2.0
#h0 = mc.fdrcorrection0(p)[0] # Effectively a threshold linear func
#h0 = p<0.05
#hiddenlayer_composition = np.multiply(hiddenlayer_composition,h0)
## multiplicative gating
##hiddenlayer_composition = np.multiply(np.multiply(np.multiply(actflow_stim, actflow_logicrule), actflow_sensoryrule), actflow_motorrule)
#### Hidden to output regions
unique_ind = np.where( | np.in1d(hidden_ind,self.motor_ind) | numpy.in1d |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Feb 24 11:53:16 2020
@author: gregz
"""
import matplotlib
matplotlib.use('agg')
import seaborn as sns
import matplotlib.pyplot as plt
from astropy.io import fits
import numpy as np
import sys
import glob
from astropy.convolution import convolve, Gaussian1DKernel
from matplotlib.ticker import MultipleLocator
from astropy.table import Table
from scipy.signal import savgol_filter, medfilt
from math_utils import biweight
filenames = [v.replace(' ', '') for v in sys.argv[1].split(',')]
filenames2 = [v.replace(' ', '') for v in sys.argv[2].split(',')]
sides = [v.replace(' ', '') for v in sys.argv[3].split(',')]
outfile = sys.argv[4]
sidedict = {'blue': ['uv', 'orange'], 'red': ['red', 'farred']}
# Plot Style
sns.set_context('talk')
sns.set_style('ticks')
plt.figure(figsize=(10, 6))
nexps = 1
waves_dict = {'uv': np.array([3670., 4050., 4200., 4420., 4500., 4560.]),
'orange': np.array([4750., 5050., 5600., 6000., 6650.]),
'red': np.array([6700., 7100., 7450., 7700., 8000.]),
'farred': np.array([8450, 8600., 8800., 9900., 10100.])}
def get_cor(calbase, channel):
waves = waves_dict[channel]
k = fits.open('%s_exp01_%s.fits' % (calbase, channel))
if 'red' in channel:
objname = k[0].header['OBJECT'].split('_066_')[0].lower()
else:
objname = k[0].header['OBJECT'].split('_056_')[0].lower()
m = np.loadtxt('/work/03946/hetdex/maverick/virus_config/standards/m%s.dat.txt' % objname)
flux = 10**(-0.4 * (m[:, 1]-23.9))*1e-29 * 2.99792e18 / m[:, 0]**2
if objname == 'gd248':
sel = m[:, 0] > 6250.
s = savgol_filter(flux[sel], 425, 2)
t = np.hstack([flux[~sel], s])
plt.plot(m[:, 0], t)
sel = m[:, 0] > 8500.
p = np.polyfit(m[sel, 0], 1./t[sel], 3)
d = m[-1, 0] - m[-2, 0]
x = np.arange(m[-1, 0]+d, 10500+d, d)
M = np.hstack([m[:, 0], x])
Y = np.hstack([t, 1./np.polyval(p, x)])
model = np.interp(k[0].data[0], M, Y)
else:
model = np.interp(k[0].data[0], m[:, 0], flux)
Z = waves*0.
for j, wave in enumerate(waves):
Z[j] = np.nanmedian((k[0].data[1] / model)[np.abs(k[0].data[0] - wave)<5.])
p = np.polyfit(waves, Z, 2)
init = np.polyval(p, k[0].data[0])
cor = k[0].data[1] / (model * init)
cor[np.abs(k[0].data[0]-6563.)<50.] = np.nan
cor[np.abs(k[0].data[0]-4861.)<50.] = np.nan
cor[np.isnan(cor)] = np.interp(k[0].data[0][np.isnan(cor)], k[0].data[0][np.isfinite(cor)],
cor[np.isfinite(cor)], left=1.0, right=1.0)
cor[k[0].data[0] < 4550.] = 1.
return init, cor
def connect_channels(spec1, spec2, def_wave, w1, w2, w3, lw, hw):
niter = 3
for j in np.arange(niter):
n3 = np.nanmedian(spec1[np.abs(def_wave-w1)<10.])
n4 = np.nanmedian(spec2[np.abs(def_wave-w2)<10.])
n5 = np.nanmedian(spec2[np.abs(def_wave-w3)<10.])
sel = (def_wave > lw) * (def_wave < hw)
sel1 = sel * np.isfinite(spec1)
sel2 = sel * np.isfinite(spec2)
p0 = np.polyfit([w1, w2, w3], [n3, n4, n5], 2)
p1 = np.polyfit(def_wave[sel1], spec1[sel1], 2)
p2 = np.polyfit(def_wave[sel2], spec2[sel2], 2)
norm = np.polyval(p0, def_wave[sel])
norm1 = np.polyval(p1, def_wave[sel])
norm2 = np.polyval(p2, def_wave[sel])
spec1[sel] = spec1[sel] / norm1 * norm
spec2[sel] = spec2[sel] / norm2 * norm
nl = np.nanmedian(spec1[np.abs(def_wave-(lw-3.))<3.])
nh = np.nanmedian(spec1[np.abs(def_wave-(lw+3.))<3.])
mult = nh / nl / 1.01
spec1[def_wave<=lw] = spec1[def_wave<=lw] * mult
nl = np.nanmedian(spec2[np.abs(def_wave-(hw-3.))<3.])
nh = np.nanmedian(spec2[np.abs(def_wave-(hw-3.))<3.])
mult = nl / nh / 1.01
spec2[def_wave>=hw] = spec2[def_wave>=hw] * mult
return spec1, spec2
def_wave = np.arange(3650., 10500., 0.7)
wave = {'uv': None, 'orange': None, 'red': None, 'farred': None}
normdict = {'blue': [4260, 4800, 5100, 4580, 4690],
'red': [8000, 8600, 8700, 8150, 8560]}
Spec = []
Cor = []
Err = []
Sky = []
allspec = []
redspec = []
bluespec = []
blueerr = []
rederr = []
bluesky = []
redsky = []
c = []
for base, calbase, side in zip(filenames, filenames2, sides):
channels = sidedict[side]
nexp = len(glob.glob('%s_exp*_%s.fits' % (base, channels[0])))
print('Found %i exposures' % nexp)
for channel in channels:
cor, CO = get_cor(calbase, channel)
for i in np.arange(1, nexp+1):
f = fits.open('%s_exp%02d_%s.fits' % (base, i, channel))
t = np.interp(def_wave, f[0].data[0], f[0].data[1] / CO / cor, left=0., right=0.)
s = np.interp(def_wave, f[0].data[0], f[0].data[2] / CO / cor, left=0., right=0.)
e = np.interp(def_wave, f[0].data[0], f[0].data[-1] / CO / cor, left=0., right=0.)
wave[channel] = def_wave
if side == 'blue':
bluespec.append(t)
blueerr.append(e)
bluesky.append(s)
else:
redspec.append(t)
rederr.append(e)
redsky.append(s)
c.append(np.interp(def_wave, f[0].data[0], CO*cor, left=0., right=0.))
N = nexp * len(channels)
w1, w2, w3, lw, hw = normdict[side]
# for i in np.arange(nexp):
# ind1 = -N + i
# ind2 = -N + nexp + i
# allspec[ind1], allspec[ind2] = connect_channels(allspec[ind1],
# allspec[ind2],
# def_wave, w1, w2, w3,
# lw, hw)
bluespec = np.array(bluespec)
bluespec[bluespec==0.] = np.nan
redspec = np.array(redspec)
redspec[redspec==0.] = np.nan
blueerr = np.array(blueerr)
blueerr[blueerr==0.] = np.nan
rederr = np.array(rederr)
rederr[rederr==0.] = np.nan
bluesky = np.array(bluesky)
bluesky[bluesky==0.] = np.nan
redsky = np.array(redsky)
redsky[redsky==0.] = np.nan
c = np.array(c)
c[c==0.] = np.nan
Blue = | np.nanmean(bluespec, axis=0) | numpy.nanmean |
"""
@author: <NAME>
@contact: <EMAIL>
"""
import matplotlib # type: ignore
import matplotlib.pyplot as plt # type: ignore
import matplotlib.patches as patches # type: ignore
import configparser
from ifpd import bioext, stats
from joblib import Parallel, delayed # type: ignore
import numpy as np # type: ignore
import os
import pandas as pd # type: ignore
from rich.progress import track # type: ignore
from typing import List
matplotlib.use("svg")
class OligoDatabase(object):
"""FISH-ProDe Oligonucleotide Database class."""
def __init__(self, dbDirPath):
super(OligoDatabase, self).__init__()
self.dirPath = dbDirPath
self.chromData = {}
assert not os.path.isfile(
self.dirPath
), f'expected folder, file found: "{self.dirPath}"'
assert os.path.isdir(
self.dirPath
), f'database folder not found: "{self.dirPath}"'
configPath = os.path.join(self.dirPath, ".config")
assert os.path.isfile(configPath), f'missing "{configPath}" file.'
with open(configPath, "r") as IH:
self.config = configparser.ConfigParser()
self.config.read_string("".join(IH.readlines()))
def check_overlaps(self):
hasOverlaps = False
for chrom, chromData in self.chromData.items():
startPositions = np.array(chromData.iloc[:-1, 0])
endPositions = np.array(chromData.iloc[1:, 1]) - 1
foundOverlaps = any(startPositions <= endPositions)
hasOverlaps |= foundOverlaps
return hasOverlaps == self.has_overlaps()
def get_oligo_length_range(self):
"""Reads oligo length range from Database .config"""
return (
self.config.getint("OLIGOS", "min_length"),
self.config.getint("OLIGOS", "max_length"),
)
def get_oligo_min_dist(self):
"""Reads consecutive oligo minimum distance from Database .config"""
return self.config.getint("OLIGOS", "min_dist")
def get_name(self):
"""Reads Database name from Database .config"""
return self.config["DATABASE"]["name"]
def get_reference_genome(self):
"""Reads reference genome from Database .config"""
return self.config["DATABASE"]["refGenome"]
def has_overlaps(self):
"""Reads overlaps status from Database .config"""
return self.config.getboolean("OLIGOS", "overlaps")
def has_sequences(self):
"""Reads sequence status from Database .config"""
return True
def has_chromosome(self, chrom):
return chrom in os.listdir(self.dirPath)
def read_chromosome(self, chrom):
assert self.has_chromosome(chrom)
chromPath = os.path.join(self.dirPath, chrom)
chromData = pd.read_csv(chromPath, "\t", header=None)
chromData.columns = bioext.UCSCbed.FIELD_NAMES[1 : (chromData.shape[1] + 1)]
assert 0 != chromData.shape[0], f'found empty chromosome file: "{chromPath}"'
assert 2 <= chromData.shape[1], f'missing columns in "{chromPath}"'
assert all(
chromData.iloc[:, 0].diff()[1:] > 0
), f'found unsorted file: "{chromPath}"'
assert all(
chromData.iloc[:, 1].diff()[1:] >= 0
), 'found unsorted file: "{chromPath}"'
oligoMinDist = self.get_oligo_min_dist()
startValues = chromData.iloc[1:, 0].values
endValues = chromData.iloc[:-1, 1].values
if len(startValues) != 0:
oligoMinD_observed = min(startValues - endValues)
else:
oligoMinD_observed = np.inf
assert oligoMinD_observed >= oligoMinDist, "".join(
[
"oligo min distance does not match: ",
f"{oligoMinD_observed} instead of {oligoMinDist}.",
]
)
oligoLengthRange = self.get_oligo_length_range()
oligoLengthList = chromData.iloc[:, 1] - chromData.iloc[:, 0]
assert all(
oligoLengthList >= oligoLengthRange[0]
), f'oligo too small for ".config" in "{chromPath}"'
assert all(
oligoLengthList <= oligoLengthRange[1]
), f'oligo too big for ".config" in "{chromPath}"'
if self.has_overlaps():
assert self.check_overlaps(), f'overlaps status mismatch in "{chromPath}"'
if self.has_sequences():
assert chromData.shape[1] >= 3, f'missing sequence columns in "{chromPath}"'
self.chromData[chrom] = chromData
def read_all_chromosomes(self, verbose):
chromList = [d for d in os.listdir(self.dirPath) if not d.startswith(".")]
assert 0 < len(chromList), "no chromosome files found in {self.dirPath}"
chromList = track(chromList) if verbose else chromList
for chrom in chromList:
self.read_chromosome(chrom)
class OligoProbe(object):
"""Class for probe management."""
def __init__(self, chrom, oligos, database):
super(OligoProbe, self).__init__()
self.chrom = chrom
self.oligoData = oligos
self.refGenome = database.get_reference_genome()
self.chromStart = self.oligoData.iloc[:, 0].min()
self.chromEnd = self.oligoData.iloc[:, 1].max()
self.midpoint = (self.chromStart + self.chromEnd) / 2
self.size = self.chromEnd - self.chromStart
self.homogeneity = self.get_probe_homogeneity()
def __str__(self):
s = f"[{self.refGenome}]"
s += f"{self.chrom}:{self.chromStart}-{self.chromEnd};"
s += f" oligoSpread: {self.homogeneity}"
return s
def asDataFrame(self, region=None):
if type(None) == type(region):
return pd.DataFrame.from_dict(
{
"chrom": [self.chrom],
"chromStart": [self.chromStart],
"chromEnd": [self.chromEnd],
"refGenome": [self.refGenome],
"midpoint": [self.midpoint],
"size": [self.size],
"homogeneity": [self.homogeneity],
}
)
else:
return pd.DataFrame.from_dict(
{
"chrom": [self.chrom],
"chromStart": [self.chromStart],
"chromEnd": [self.chromEnd],
"refGenome": [self.refGenome],
"midpoint": [self.midpoint],
"size": [self.size],
"homogeneity": [self.homogeneity],
"regChromStart": region[0],
"regChromEnd": region[1],
}
)
def get_probe_centrality(self, region):
"""Calculate centrality, as location of the probe midpoint relative to
the region midpoint. 1 when overlapping, 0 when the probe midpoint is
at either of the region extremities."""
region_halfWidth = (region[2] - region[1]) / 2
region_midPoint = region[1] + region_halfWidth
return (
region_halfWidth - abs(region_midPoint - self.midpoint)
) / region_halfWidth
def get_probe_size(self):
"""Probe size, defined as difference between start of first oligo
and end of the last one."""
return self.oligoData.iloc[:, 1].max() - self.oligoData.iloc[:, 0].min()
def get_probe_homogeneity(self):
"""Probe homogeneity, as the inverse of the standard deviation of the
distance between consecutive oligos, calculated from their start
position, disregarding oligo length."""
std = np.std(np.diff(self.oligoData.iloc[:, 1]))
return np.inf if std == 0 else 1 / std
def describe(self, region, path=None):
"""Builds a small pd.DataFrame describing a probe."""
description = pd.DataFrame.from_dict(
{
"chrom": [region[0]],
"chromStart": [self.oligoData.iloc[:, 0].min()],
"chromEnd": [self.oligoData.iloc[:, 1].max()],
"centrality": [self.get_probe_centrality(region)],
"size": [self.size],
"homogeneity": [self.homogeneity],
}
)
if type(None) != type(path):
config = configparser.ConfigParser()
config["REGION"] = {
"chrom": region[0],
"chromStart": region[1],
"chromEnd": region[2],
}
config["PROBE"] = {
"chrom": description["chrom"].values[0],
"chromStart": description["chromStart"].values[0],
"chromEnd": description["chromEnd"].values[0],
"nOligo": self.oligoData.shape[0],
}
config["FEATURES"] = {
"centrality": description["centrality"].values[0],
"size": description["size"].values[0],
"homogeneity": description["homogeneity"].values[0],
}
with open(path, "w+") as OH:
config.write(OH)
return description
def get_fasta(self, path=None, prefix=""):
if not prefix.startswith(" "):
prefix = " " + prefix
fasta = ""
for i in self.oligoData.index:
oligo = self.oligoData.loc[i, :]
chromStart, chromEnd, sequence = oligo[:3]
fasta += f">{prefix}oligo_{i} [{self.refGenome}]"
fasta += f"{self.chrom}:{chromStart}-{chromEnd}\n"
fasta += f"{sequence}\n"
if type(None) != type(path):
assert os.path.isdir(os.path.dirname(path))
with open(path, "w+") as OH:
OH.write(fasta)
return fasta
def get_bed(self, path=None, prefix=""):
if not prefix.endswith("_"):
prefix += "_"
bed = f'track description="ref:{self.refGenome}"\n'
for i in self.oligoData.index:
oligo = self.oligoData.loc[i, :]
chromStart, chromEnd, sequence = oligo[:3]
bed += f"{self.chrom}\t{chromStart}\t{chromEnd}\t"
bed += f"{prefix}oligo_{i}\n"
if type(None) != type(path):
assert os.path.isdir(os.path.dirname(path))
with open(path, "w+") as OH:
OH.write(bed)
return bed
def _plot_region(self, outputDir, region):
fig = plt.figure()
chrom, start, stop = region
plt.plot([start, stop], [0, 0], "k", linewidth=4.0, label="Genome")
plt.plot(
[start + (stop - start) / 2.0, start + (stop - start) / 2.0],
[-1, 1],
"r--",
label="Window center",
)
plt.plot(
[self.chromStart, self.chromEnd], [0, 0], "c-", linewidth=4.0, label="Probe"
)
plt.plot(
[self.chromStart + self.size / 2.0, self.chromStart + self.size / 2.0],
[-1, 1],
"c--",
label="Probe center",
)
plt.gca().axes.get_yaxis().set_visible(False)
plt.suptitle("%s:%d-%.0f" % (chrom, start, stop))
plt.xlabel("genomic coordinate [nt]")
plt.legend(fontsize="small", loc="best")
plt.savefig(
os.path.join(outputDir, "window.png"), format="png", bbox_inches="tight"
)
plt.close(fig)
def _plot_oligo(self, outputDir):
fig = plt.figure(figsize=(20, 5))
(genome_handle,) = plt.plot(
[self.chromStart, self.chromEnd], [0, 0], "k", linewidth=4.0, label="Genome"
)
for i in self.oligoData.index:
oligo = self.oligoData.loc[i, :]
oligo_midpoint = (oligo["chromStart"] + oligo["chromEnd"]) / 2.0
(oligo_handle,) = plt.plot(
[oligo["chromStart"], oligo["chromEnd"]],
[0, 0],
"c",
linewidth=2.0,
label="Oligo",
)
(oligoCenter_handle,) = plt.plot(
[oligo_midpoint, oligo_midpoint],
[-0.1, 0.1],
"c:",
label="Oligo center",
)
plt.gca().axes.get_yaxis().set_visible(False)
plt.ylim((-0.5, 0.5))
plt.gca().axes.get_xaxis().set_ticks(
list(
range(
self.chromStart,
self.chromEnd,
max(1, int((self.chromEnd - self.chromStart) / 5.0)),
)
)
)
plt.legend(
handles=[genome_handle, oligo_handle, oligoCenter_handle],
fontsize="small",
loc="best",
)
plt.suptitle((f"{self.chrom}:{self.chromStart}-{self.chromEnd}"))
plt.xlabel("genomic coordinate [nt]")
plt.savefig(
os.path.join(outputDir, "probe.png"), format="png", bbox_inches="tight"
)
plt.close(fig)
def _plot_oligo_distr(self, outputDir):
fig = plt.figure()
plt.plot(
[0, self.oligoData.shape[0] - 1],
[self.chromStart, self.chromEnd],
"k-",
label="Homogeneous distribution",
)
plt.plot(
list(range(self.oligoData.shape[0])),
self.oligoData["chromStart"].values,
"r.",
label="Oligo",
)
plt.suptitle(f"{self.chrom}:{self.chromStart}-{self.chromEnd}")
plt.xlabel("oligo number")
plt.ylabel("genomic coordinate [nt]")
plt.legend(fontsize="small", loc="best")
plt.savefig(os.path.join(outputDir, "oligo.png"), format="png")
plt.close(fig)
def _plot_oligo_distance(self, outputDir):
fig = plt.figure()
if self.oligoData.shape[0] > 1:
startPositions = self.oligoData.iloc[1:, 0].values
endPositions = self.oligoData.iloc[:-1, 1].values
diffs = startPositions - endPositions
plt.hist(diffs, density=1, facecolor="green", alpha=0.5)
density = stats.calc_density(diffs, alpha=0.5)
plt.plot(
density["x"].tolist(),
density["y"].tolist(),
"b--",
label="Density distribution",
)
plt.suptitle(f"{self.chrom}:{self.chromStart}-{self.chromEnd}")
plt.legend(fontsize="small", loc="best")
plt.xlabel("Distance between consecutive oligos [nt]")
plt.ylabel("Density")
plt.savefig(os.path.join(outputDir, "distance.png"), format="png")
plt.close(fig)
def plot(self, outputDir, region):
assert os.path.isdir(outputDir), f'folder not found: "{outputDir}"'
self._plot_region(outputDir, region)
self._plot_oligo(outputDir)
self._plot_oligo_distr(outputDir)
self._plot_oligo_distance(outputDir)
def describe_candidate(candidate, queried_region):
return candidate.describe(queried_region)
class ProbeFeatureTable(object):
FEATURE_SORT = {
"centrality": {"ascending": False},
"size": {"ascending": True},
"homogeneity": {"ascending": False},
}
def __init__(self, candidateList, queried_region, verbose=False, threads=1):
super(ProbeFeatureTable, self).__init__()
assert 0 < len(candidateList)
self.data = []
if threads != 1:
verbose = 1 if verbose else 0
self.data = Parallel(n_jobs=threads, backend="threading", verbose=verbose)(
delayed(describe_candidate)(candidate, queried_region)
for candidate in candidateList
)
else:
candidateList = track(candidateList) if verbose else candidateList
for candidate in candidateList:
self.data.append(candidate.describe(queried_region))
self.data = pd.concat(self.data)
self.data.index = range(self.data.shape[0])
self.discarded = None
def reset(self):
self.data = pd.concat([self.discarded, self.data])
self.discarded = None
self.data.sort_index(inplace=True)
def keep(self, condition, cumulative=False):
if not cumulative:
self.reset()
self.discarded = pd.concat(
[self.discarded, self.data.loc[np.logical_not(condition), :]]
)
self.data = self.data.loc[condition, :]
def filter(self, feature, thr, cumulative=False):
assert (
feature in self.FEATURE_SORT.keys()
), f'fetature "{feature}" not recognized.'
if not cumulative:
self.reset()
self.rank(feature)
best_feature = self.data[feature].values[0]
feature_delta = best_feature * thr
feature_range = (best_feature - feature_delta, best_feature + feature_delta)
discardCondition = [
self.data[feature] < feature_range[0],
self.data[feature] > feature_range[1],
]
discardCondition = np.logical_or(*discardCondition)
self.discarded = pd.concat([self.discarded, self.data.loc[discardCondition, :]])
self.data = self.data.loc[np.logical_not(discardCondition), :]
return (feature_range, feature)
def rank(self, feature):
self.data = self.data.sort_values(
feature, ascending=self.FEATURE_SORT[feature]["ascending"]
)
class GenomicWindow(object):
def __init__(self, chrom, start, size):
super(GenomicWindow, self).__init__()
self.chrom = chrom
self.chromStart = start
self.chromEnd = start + size
self.midpoint = (self.chromStart + self.chromEnd) / 2
self.size = size
self.probe = None
def __str__(self):
s = f"[GenomicWindow]{self.chrom}:{self.chromStart}-{self.chromEnd}\n"
s += f" Probe: {self.probe}"
return s
def asRegion(self):
return (self.chrom, self.chromStart, self.chromEnd)
def has_probe(self):
return self.probe is not None
def shift(self, n):
return GenomicWindow(self.chrom, self.chromStart + n, self.size)
def __repr__(self):
return f"{self.chrom}:{self.chromStart}-{self.chromEnd}"
class GenomicWindowList(object):
"""Both a list genomic window and associated probe set."""
data: List = []
def __init__(self, windows=None):
super(GenomicWindowList, self).__init__()
if type(None) != type(windows):
self.data = windows
def __getitem__(self, i):
return self.data[i]
def __iter__(self):
yield from self.data
def __len__(self):
return len(self.data)
def add(self, chrom, start, size):
self.data.append(GenomicWindow(chrom, start, size))
def count_probes(self):
return sum(w.has_probe() for w in self)
def shift(self, n):
return GenomicWindowList([window.shift(n) for window in self.data])
def sort(self):
midpointList = np.array([w.midpoint for w in self.data])
self.data = [self.data[i] for i in | np.argsort(midpointList) | numpy.argsort |
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from scipy.sparse import issparse
from pandas.api.types import is_numeric_dtype, is_categorical_dtype, is_list_like
from scipy.stats import zscore
from sklearn.metrics import adjusted_mutual_info_score
from natsort import natsorted
import anndata
from pegasusio import UnimodalData, MultimodalData
from typing import List, Tuple, Union, Optional, Callable
import logging
logger = logging.getLogger(__name__)
from pegasus.tools import X_from_rep, slicing
from .plot_utils import _transform_basis, _get_nrows_and_ncols, _get_marker_size, _get_dot_size, _get_subplot_layouts, _get_legend_ncol, _get_palette, RestrictionParser, DictWithDefault, _generate_categories, _plot_corners
def scatter(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
attrs: Union[str, List[str]],
basis: Optional[str] = "umap",
matkey: Optional[str] = None,
restrictions: Optional[Union[str, List[str]]] = None,
show_background: Optional[bool] = False,
alpha: Optional[Union[float, List[float]]] = 1.0,
legend_loc: Optional[Union[str, List[str]]] = "right margin",
legend_ncol: Optional[str] = None,
palettes: Optional[Union[str, List[str]]] = None,
cmaps: Optional[Union[str, List[str]]] = "YlOrRd",
vmin: Optional[float] = None,
vmax: Optional[float] = None,
nrows: Optional[int] = None,
ncols: Optional[int] = None,
panel_size: Optional[Tuple[float, float]] = (4, 4),
left: Optional[float] = 0.2,
bottom: Optional[float] = 0.15,
wspace: Optional[float] = 0.4,
hspace: Optional[float] = 0.15,
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
**kwargs,
) -> Union[plt.Figure, None]:
"""Generate scatter plots for different attributes
Parameters
----------
data: ``pegasusio.MultimodalData``
Use current selected modality in data.
attrs: ``str`` or ``List[str]``
Color scatter plots by attrs. Each attribute in attrs can be one key in data.obs, data.var_names (e.g. one gene) or data.obsm (attribute has the format of 'obsm_key@component', like 'X_pca@0'). If one attribute is categorical, a palette will be used to color each category separately. Otherwise, a color map will be used.
basis: ``str``, optional, default: ``umap``
Basis to be used to generate scatter plots. Can be either 'umap', 'tsne', 'fitsne', 'fle', 'net_tsne', 'net_fitsne', 'net_umap' or 'net_fle'.
matkey: ``str``, optional, default: None
If matkey is set, select matrix with matkey as keyword in the current modality. Only works for MultimodalData or UnimodalData objects.
restrictions: ``str`` or ``List[str]``, optional, default: None
A list of restrictions to subset data for plotting. There are two types of restrictions: global restriction and attribute-specific restriction. Global restriction appiles to all attributes in ``attrs`` and takes the format of 'key:value,value...', or 'key:~value,value...'. This restriction selects cells with the ``data.obs[key]`` values belong to 'value,value...' (or not belong to if '~' shows). Attribute-specific restriction takes the format of 'attr:key:value,value...', or 'attr:key:~value,value...'. It only applies to one attribute 'attr'. If 'attr' and 'key' are the same, one can use '.' to replace 'key' (e.g. ``cluster_labels:.:value1,value2``).
show_background: ``bool``, optional, default: False
Only applicable if `restrictions` is set. By default, only data points selected are shown. If show_background is True, data points that are not selected will also be shown.
alpha: ``float`` or ``List[float]``, optional, default: ``1.0``
Alpha value for blending, from 0.0 (transparent) to 1.0 (opaque). If this is a list, the length must match attrs, which means we set a separate alpha value for each attribute.
legend_loc: ``str`` or ``List[str]``, optional, default: ``right margin``
Legend location. Can be either "right margin" or "on data". If a list is provided, set 'legend_loc' for each attribute in 'attrs' separately.
legend_ncol: ``str``, optional, default: None
Only applicable if legend_loc == "right margin". Set number of columns used to show legends.
palettes: ``str`` or ``List[str]``, optional, default: None
Used for setting colors for every categories in categorical attributes. Each string in ``palettes`` takes the format of 'attr:color1,color2,...,colorn'. 'attr' is the categorical attribute and 'color1' - 'colorn' are the colors for each category in 'attr' (e.g. 'cluster_labels:black,blue,red,...,yellow'). If there is only one categorical attribute in 'attrs', ``palletes`` can be set as a single string and the 'attr' keyword can be omitted (e.g. "blue,yellow,red").
cmaps: ``str`` or ``List[str]``, optional, default: ``YlOrRd``
Used for setting colormap for numeric attributes. Each string in ``cmaps`` takes the format of 'colormap' or 'attr:colormap'. 'colormap' sets the default colormap for all numeric attributes. 'attr:colormap' overwrites attribute 'attr's colormap as 'colormap'.
vmin: ``float``, optional, default: None
Minimum value to show on a numeric scatter plot (feature plot).
vmax: ``float``, optional, default: None
Maximum value to show on a numeric scatter plot (feature plot).
nrows: ``int``, optional, default: None
Number of rows in the figure. If not set, pegasus will figure it out automatically.
ncols: ``int``, optional, default: None
Number of columns in the figure. If not set, pegasus will figure it out automatically.
panel_size: `tuple`, optional (default: `(6, 4)`)
The panel size (width, height) in inches.
left: `float`, optional (default: `0.2`)
This parameter sets the figure's left margin as a fraction of panel's width (left * panel_size[0]).
bottom: `float`, optional (default: `0.15`)
This parameter sets the figure's bottom margin as a fraction of panel's height (bottom * panel_size[1]).
wspace: `float`, optional (default: `0.4`)
This parameter sets the width between panels and also the figure's right margin as a fraction of panel's width (wspace * panel_size[0]).
hspace: `float`, optional (defualt: `0.15`)
This parameter sets the height between panels and also the figure's top margin as a fraction of panel's height (hspace * panel_size[1]).
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: 300.0
The resolution of the figure in dots-per-inch.
Returns
-------
`Figure` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``return_fig == True``
Examples
--------
>>> pg.scatter(data, attrs=['louvain_labels', 'Channel'], basis='fitsne')
>>> pg.scatter(data, attrs=['CD14', 'TRAC'], basis='umap')
"""
if not is_list_like(attrs):
attrs = [attrs]
nattrs = len(attrs)
if not isinstance(data, anndata.AnnData):
cur_matkey = data.current_matrix()
if matkey is not None:
assert not isinstance(data, anndata.AnnData)
data.select_matrix(matkey)
x = data.obsm[f"X_{basis}"][:, 0]
y = data.obsm[f"X_{basis}"][:, 1]
# four corners of the plot
corners = np.array(np.meshgrid([x.min(), x.max()], [y.min(), y.max()])).T.reshape(-1, 2)
basis = _transform_basis(basis)
marker_size = _get_marker_size(x.size)
nrows, ncols = _get_nrows_and_ncols(nattrs, nrows, ncols)
fig, axes = _get_subplot_layouts(nrows=nrows, ncols=ncols, panel_size=panel_size, dpi=dpi, left=left, bottom=bottom, wspace=wspace, hspace=hspace, squeeze=False)
if not is_list_like(alpha):
alpha = [alpha] * nattrs
if not is_list_like(legend_loc):
legend_loc = [legend_loc] * nattrs
legend_fontsize = [5 if x == "on data" else 10 for x in legend_loc]
palettes = DictWithDefault(palettes)
cmaps = DictWithDefault(cmaps)
restr_obj = RestrictionParser(restrictions)
restr_obj.calc_default(data)
for i in range(nrows):
for j in range(ncols):
ax = axes[i, j]
ax.grid(False)
ax.set_xticks([])
ax.set_yticks([])
if i * ncols + j < nattrs:
pos = i * ncols + j
attr = attrs[pos]
if attr in data.obs:
values = data.obs[attr].values
elif attr in data.var_names:
loc = data.var_names.get_loc(attr)
values = slicing(data.X, col = loc)
else:
obsm_key, sep, component = attr.partition("@")
if (sep != "@") or (obsm_key not in data.obsm) or (not component.isdigit()):
raise KeyError(f"{attr} is not in data.obs, data.var_names or data.obsm!")
values = data.obsm[obsm_key][:, int(component)]
selected = restr_obj.get_satisfied(data, attr)
if is_numeric_dtype(values):
cmap = cmaps.get(attr, squeeze = True)
if cmap is None:
raise KeyError(f"Please set colormap for attribute {attr} or set a default colormap!")
_plot_corners(ax, corners, marker_size)
img = ax.scatter(
x[selected],
y[selected],
c=values[selected],
s=marker_size,
marker=".",
alpha=alpha[pos],
edgecolors="none",
cmap=cmap,
vmin=vmin,
vmax=vmax,
rasterized=True,
)
left, bottom, width, height = ax.get_position().bounds
rect = [left + width * (1.0 + 0.05), bottom, width * 0.1, height]
ax_colorbar = fig.add_axes(rect)
fig.colorbar(img, cax=ax_colorbar)
else:
labels, with_background = _generate_categories(values, restr_obj.get_satisfied(data, attr))
label_size = labels.categories.size
palette = palettes.get(attr)
if palette is None:
palette = _get_palette(label_size, with_background=with_background, show_background=show_background)
elif with_background:
palette = ["gainsboro" if show_background else "white"] + list(palette)
text_list = []
for k, cat in enumerate(labels.categories):
idx = labels == cat
if idx.sum() > 0:
scatter_kwargs = {"marker": ".", "alpha": alpha[pos], "edgecolors": "none", "rasterized": True}
if cat != "":
if legend_loc[pos] != "on data":
scatter_kwargs["label"] = cat
else:
text_list.append((np.median(x[idx]), np.median(y[idx]), cat))
if cat != "" or (cat == "" and show_background):
ax.scatter(
x[idx],
y[idx],
c=palette[k],
s=marker_size,
**scatter_kwargs,
)
else:
_plot_corners(ax, corners, marker_size)
if legend_loc[pos] == "right margin":
legend = ax.legend(
loc="center left",
bbox_to_anchor=(1, 0.5),
frameon=False,
fontsize=legend_fontsize[pos],
ncol=_get_legend_ncol(label_size, legend_ncol),
)
for handle in legend.legendHandles:
handle.set_sizes([300.0])
elif legend_loc[pos] == "on data":
texts = []
for px, py, txt in text_list:
texts.append(ax.text(px, py, txt, fontsize=legend_fontsize[pos], fontweight = "bold", ha = "center", va = "center"))
# from adjustText import adjust_text
# adjust_text(texts, arrowprops=dict(arrowstyle='-', color='k', lw=0.5))
ax.set_title(attr)
else:
ax.set_frame_on(False)
if i == nrows - 1:
ax.set_xlabel(f"{basis}1")
if j == 0:
ax.set_ylabel(f"{basis}2")
# Reset current matrix if needed.
if not isinstance(data, anndata.AnnData):
if cur_matkey != data.current_matrix():
data.select_matrix(cur_matkey)
return fig if return_fig else None
def scatter_groups(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
attr: str,
groupby: str,
basis: Optional[str] = "umap",
matkey: Optional[str] = None,
restrictions: Optional[Union[str, List[str]]] = None,
show_full: Optional[bool] = True,
categories: Optional[List[str]] = None,
alpha: Optional[float] = 1.0,
legend_loc: Optional[str] = "right margin",
legend_ncol: Optional[str] = None,
palette: Optional[str] = None,
cmap: Optional[str] = "YlOrRd",
vmin: Optional[float] = None,
vmax: Optional[float] = None,
nrows: Optional[int] = None,
ncols: Optional[int] = None,
panel_size: Optional[Tuple[float, float]] = (4, 4),
left: Optional[float] = 0.2,
bottom: Optional[float] = 0.15,
wspace: Optional[float] = 0.4,
hspace: Optional[float] = 0.15,
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
**kwargs,
) -> Union[plt.Figure, None]:
""" Generate scatter plots of attribute 'attr' for each category in attribute 'group'. Optionally show scatter plot containing data points from all categories in 'group'.
Parameters
----------
data: ``pegasusio.MultimodalData``
Use current selected modality in data.
attr: ``str``
Color scatter plots by attribute 'attr'. This attribute should be one key in data.obs, data.var_names (e.g. one gene) or data.obsm (attribute has the format of 'obsm_key@component', like 'X_pca@0'). If it is categorical, a palette will be used to color each category separately. Otherwise, a color map will be used.
groupby: ``str``
Generate separate scatter plots of 'attr' for data points in each category in 'groupby', which should be a key in data.obs representing one categorical variable.
basis: ``str``, optional, default: ``umap``
Basis to be used to generate scatter plots. Can be either 'umap', 'tsne', 'fitsne', 'fle', 'net_tsne', 'net_fitsne', 'net_umap' or 'net_fle'.
matkey: ``str``, optional, default: None
If matkey is set, select matrix with matkey as keyword in the current modality. Only works for MultimodalData or UnimodalData objects.
restrictions: ``str`` or ``List[str]``, optional, default: None
A list of restrictions to subset data for plotting. Each restriction takes the format of 'key:value,value...', or 'key:~value,value...'. This restriction selects cells with the ``data.obs[key]`` values belong to 'value,value...' (or not belong to if '~' shows).
show_full: ``bool``, optional, default: True
Show the scatter plot with all categories in 'groupby' as the first plot.
categories: ``List[str]``, optional, default: None
Redefine group structure based on attribute 'groupby'. If 'categories' is not None, each string in the list takes the format of 'category_name:value,value', or 'category_name:~value,value...", where 'category_name' refers to new category name, 'value' refers to one of the category in 'groupby' and '~' refers to exclude values.
alpha: ``float``, optional, default: ``1.0``
Alpha value for blending, from 0.0 (transparent) to 1.0 (opaque).
legend_loc: ``str``, optional, default: ``right margin``
Legend location. Can be either "right margin" or "on data".
legend_ncol: ``str``, optional, default: None
Only applicable if legend_loc == "right margin". Set number of columns used to show legends.
palette: ``str``, optional, default: None
Used for setting colors for one categorical attribute (e.g. "black,blue,red,...,yellow").
cmap: ``str``, optional, default: ``YlOrRd``
Used for setting colormap for one numeric attribute.
vmin: ``float``, optional, default: None
Minimum value to show on a numeric scatter plot (feature plot).
vmax: ``float``, optional, default: None
Maximum value to show on a numeric scatter plot (feature plot).
nrows: ``int``, optional, default: None
Number of rows in the figure. If not set, pegasus will figure it out automatically.
ncols: ``int``, optional, default: None
Number of columns in the figure. If not set, pegasus will figure it out automatically.
panel_size: `tuple`, optional (default: `(6, 4)`)
The panel size (width, height) in inches.
left: `float`, optional (default: `0.2`)
This parameter sets the figure's left margin as a fraction of panel's width (left * panel_size[0]).
bottom: `float`, optional (default: `0.15`)
This parameter sets the figure's bottom margin as a fraction of panel's height (bottom * panel_size[1]).
wspace: `float`, optional (default: `0.4`)
This parameter sets the width between panels and also the figure's right margin as a fraction of panel's width (wspace * panel_size[0]).
hspace: `float`, optional (defualt: `0.15`)
This parameter sets the height between panels and also the figure's top margin as a fraction of panel's height (hspace * panel_size[1]).
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: 300.0
The resolution of the figure in dots-per-inch.
Returns
-------
`Figure` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``return_fig == True``
Examples
--------
>>> pg.scatter_groups(data, attr='louvain_labels', groupby='Individual', basis='tsne', nrows = 2, ncols = 4, alpha = 0.5)
>>> pg.scatter_groups(data, attr='anno', groupby='Channel', basis='umap', categories=['new_cat1:channel1,channel2', 'new_cat2:channel3'])
"""
if not isinstance(data, anndata.AnnData):
cur_matkey = data.current_matrix()
if matkey is not None:
assert not isinstance(data, anndata.AnnData)
data.select_matrix(matkey)
x = data.obsm[f"X_{basis}"][:, 0]
y = data.obsm[f"X_{basis}"][:, 1]
# four corners of the plot
corners = np.array(np.meshgrid([x.min(), x.max()], [y.min(), y.max()])).T.reshape(-1, 2)
basis = _transform_basis(basis)
marker_size = _get_marker_size(x.size)
if attr in data.obs:
values = data.obs[attr].values
elif attr in data.var_names:
loc = data.var_names.get_loc(attr)
values = slicing(data.X, col = loc)
else:
obsm_key, sep, component = attr.partition("@")
if (sep != "@") or (obsm_key not in data.obsm) or (not component.isdigit()):
raise KeyError(f"{attr} is not in data.obs, data.var_names or data.obsm!")
values = data.obsm[obsm_key][:, int(component)]
is_cat = is_categorical_dtype(values)
if (not is_cat) and (not is_numeric_dtype(values)):
values = pd.Categorical(values, categories=natsorted(np.unique(values)))
is_cat = True
assert groupby in data.obs
groups = data.obs[groupby].values
if not is_categorical_dtype(groups):
groups = pd.Categorical(groups, categories=natsorted(np.unique(groups)))
restr_obj = RestrictionParser(restrictions)
restr_obj.calc_default(data)
selected = restr_obj.get_satisfied(data)
nsel = selected.sum()
if nsel < data.shape[0]:
x = x[selected]
y = y[selected]
values = values[selected]
groups = groups[selected]
df_g = pd.DataFrame()
if show_full:
df_g["All"] = np.ones(nsel, dtype=bool)
if categories is None:
for cat in groups.categories:
df_g[cat] = groups == cat
else:
cat_obj = RestrictionParser(categories)
for cat, idx in cat_obj.next_category(groups):
df_g[cat] = idx
nrows, ncols = _get_nrows_and_ncols(df_g.shape[1], nrows, ncols)
fig, axes = _get_subplot_layouts(nrows=nrows, ncols=ncols, panel_size=panel_size, dpi=dpi, left=left, bottom=bottom, wspace=wspace, hspace=hspace, squeeze=False)
legend_fontsize = 5 if legend_loc == 'on data' else 10
if is_cat:
labels = values
label_size = labels.categories.size
palette = _get_palette(label_size) if palette is None else np.array(palette.split(","))
legend_ncol = _get_legend_ncol(label_size, legend_ncol)
for i in range(nrows):
for j in range(ncols):
ax = axes[i, j]
ax.grid(False)
ax.set_xticks([])
ax.set_yticks([])
gid = i * ncols + j
if gid < df_g.shape[1]:
if is_cat:
text_list = []
for k, cat in enumerate(labels.categories):
idx = np.logical_and(df_g.iloc[:, gid].values, labels == cat)
_plot_corners(ax, corners, marker_size)
if idx.sum() > 0:
scatter_kwargs = {"marker": ".", "alpha": alpha, "edgecolors": "none", "rasterized": True}
if legend_loc != "on data":
scatter_kwargs["label"] = str(cat)
else:
text_list.append((np.median(x[idx]), np.median(y[idx]), str(cat)))
ax.scatter(
x[idx],
y[idx],
c=palette[k],
s=marker_size,
**scatter_kwargs,
)
if legend_loc == "right margin":
legend = ax.legend(
loc="center left",
bbox_to_anchor=(1, 0.5),
frameon=False,
fontsize=legend_fontsize,
ncol=legend_ncol,
)
for handle in legend.legendHandles:
handle.set_sizes([300.0])
elif legend_loc == "on data":
texts = []
for px, py, txt in text_list:
texts.append(ax.text(px, py, txt, fontsize=legend_fontsize, fontweight = "bold", ha = "center", va = "center"))
else:
_plot_corners(ax, corners, marker_size)
idx_g = df_g.iloc[:, gid].values
img = ax.scatter(
x[idx_g],
y[idx_g],
s=marker_size,
c=values[idx_g],
marker=".",
alpha=alpha,
edgecolors="none",
cmap=cmap,
vmin=vmin,
vmax=vmax,
rasterized=True,
)
left, bottom, width, height = ax.get_position().bounds
rect = [left + width * (1.0 + 0.05), bottom, width * 0.1, height]
ax_colorbar = fig.add_axes(rect)
fig.colorbar(img, cax=ax_colorbar)
ax.set_title(str(df_g.columns[gid]))
else:
ax.set_frame_on(False)
if i == nrows - 1:
ax.set_xlabel(basis + "1")
if j == 0:
ax.set_ylabel(basis + "2")
if not isinstance(data, anndata.AnnData):
if cur_matkey != data.current_matrix():
data.select_matrix(cur_matkey)
return fig if return_fig else None
def compo_plot(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
groupby: str,
condition: str,
style: Optional[str] = "frequency",
restrictions: Optional[Union[str, List[str]]] = None,
switch_axes: Optional[bool] = False,
groupby_label: Optional[str] = None,
sort_function: Union[Callable[[List[str]], List[str]], str] = 'natsorted',
panel_size: Optional[Tuple[float, float]] = (6, 4),
palette: Optional[List[str]] = None,
color_unused: bool = False,
left: Optional[float] = 0.15,
bottom: Optional[float] = 0.15,
wspace: Optional[float] = 0.3,
hspace: Optional[float] = 0.15,
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
**kwargs,
) -> Union[plt.Figure, None]:
"""Generate a composition plot, which shows the percentage of cells from each condition for every cluster.
This function is used to generate composition plots, which are bar plots showing the cell compositions (from different conditions) for each cluster. This type of plots is useful to fast assess library quality and batch effects.
Parameters
----------
data : ``AnnData`` or ``UnimodalData`` or ``MultimodalData`` object
Single cell expression data.
groupby : ``str``
A categorical variable in data.obs that is used to categorize the cells, e.g. cell type.
condition: ``str``
A categorical variable in data.obs that is used to calculate frequency within each category defined by ``groupby``, e.g. donor.
style: ``str``, optional (default: ``frequency``)
Composition plot style. Can be either ``frequency``, or ``normalized``. Within each cluster, the ``frequency`` style show the percentage of cells from each ``condition`` within each category in ``groupby`` (stacked), the ``normalized`` style shows for each category in ``groupby`` the percentage of cells that are also in each ``condition`` over all cells that are in the same ``condition`` (not stacked).
restrictions: ``str`` or ``List[str]``, optional, default: None
A list of restrictions to subset data for plotting. Each restriction takes the format of 'key:value,value...', or 'key:~value,value...'. This restriction selects cells with the ``data.obs[key]`` values belong to 'value,value...' (or not belong to if '~' shows).
switch_axes: ``bool``, optional, default: ``False``
By default, X axis is for groupby, and Y axis for frequencies with respect to condition. If this parameter is ``True``, switch the axes.
groupby_label: ``str``, optional (default ``None``)
Label for the axis displaying ``groupby`` categories. If ``None``, use ``groupby``.
sort_function: ``Union[Callable[List[str], List[str]], str]``, optional, default: ``natsorted``
Function used for sorting both groupby and condition labels. If ``natsorted``, apply natsorted function to sort by natural order. If ``None``, don't sort. Otherwise, a callable function will be applied to the labels for sorting.
panel_size: ``tuple``, optional (default: ``(6, 4)``)
The plot size (width, height) in inches.
palette: ``List[str]``, optional (default: ``None``)
Used for setting colors for categories in ``condition``. Within the list, each string is the color for one category.
left: ``float``, optional (default: ``0.15``)
This parameter sets the figure's left margin as a fraction of panel's width (left * panel_size[0]).
bottom: ``float``, optional (default: ``0.15``)
This parameter sets the figure's bottom margin as a fraction of panel's height (bottom * panel_size[1]).
wspace: ``float``, optional (default: ``0.3``)
This parameter sets the width between panels and also the figure's right margin as a fraction of panel's width (wspace * panel_size[0]).
hspace: ``float``, optional (defualt: ``0.15``)
This parameter sets the height between panels and also the figure's top margin as a fraction of panel's height (hspace * panel_size[1]).
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: ``300.0``
The resolution in dots per inch.
Returns
-------
``Figure`` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``return_fig == True``
Examples
--------
>>> fig = pg.compo_plot(data, 'louvain_labels', 'Donor', style = 'normalized')
"""
if groupby_label is None:
groupby_label = groupby
fig, ax = _get_subplot_layouts(panel_size=panel_size, dpi=dpi, left=left, bottom=bottom, wspace=wspace, hspace=hspace) # default nrows = 1 & ncols = 1
restr_obj = RestrictionParser(restrictions)
restr_obj.calc_default(data)
selected = restr_obj.get_satisfied(data)
df = pd.crosstab(data.obs.loc[selected, groupby], data.obs.loc[selected, condition])
index_values = df.index.tolist()
column_values = df.columns.tolist()
if sort_function == "natsorted":
sort_function = natsorted
if callable(sort_function):
index_values = sort_function(index_values)
column_values = sort_function(column_values)
if switch_axes:
index_values.reverse()
df = df.reindex(index = index_values, columns = column_values)
if style == "frequency":
df = df.div(df.sum(axis=1), axis=0) * 100.0
else:
assert style == "normalized"
df = df.div(df.sum(axis=0), axis=1) * 100.0
if color_unused:
if palette is None:
color_list = _get_palette(data.obs[condition].cat.categories.size)
else:
assert len(palette) >= data.obs[condition].cat.categories.size, "The palette provided has fewer colors than needed!"
color_idx = df.columns.map(data.obs[condition].cat.categories.get_loc)
color_list = palette[color_idx]
else:
if palette is None:
color_list = _get_palette(df.shape[1])
else:
assert len(palette) >= df.shape[1], "The palette provided has fewer colors than needed!"
color_list = palette[0:df.shape[1]]
df.plot(
kind = "bar" if not switch_axes else "barh",
stacked = style == "frequency",
legend = False,
color = color_list,
ax = ax,
)
ax.grid(False)
if not switch_axes:
ax.set_xlabel(groupby_label)
ax.set_ylabel("Percentage")
else:
ax.set_xlabel("Percentage")
ax.set_ylabel(groupby_label)
ax.legend(loc="center left", bbox_to_anchor=(1.05, 0.5))
if len(max(df.index.astype(str), key=len)) >= 5:
ax.set_xticklabels(ax.get_xticklabels(), rotation=-45, ha='left')
return fig if return_fig else None
def violin(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
attrs: Union[str, List[str]],
groupby: str,
hue: Optional[str] = None,
matkey: Optional[str] = None,
stripplot: Optional[bool] = False,
inner: Optional[str] = None,
scale: Optional[str] = 'width',
panel_size: Optional[Tuple[float, float]] = (8, 0.5),
palette: Optional[List[str]] = None,
left: Optional[float] = 0.15,
bottom: Optional[float] = 0.15,
wspace: Optional[float] = 0.1,
ylabel: Optional[str] = None,
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
**kwargs,
) -> Union[plt.Figure, None]:
"""
Generate a stacked violin plot.
Parameters
----------
data: ``AnnData`` or ``MultimodalData`` or ``UnimodalData`` object
Single-cell expression data.
attrs: ``str`` or ``List[str]``
Cell attributes or features to plot.
Cell attributes must exist in ``data.obs`` and must be numeric.
Features must exist in ``data.var``.
groupby: ``str``
A categorical variable in data.obs that is used to categorize the cells, e.g. Clusters.
hue: ``str``, optional, default: None
'hue' should be a categorical variable in data.obs that has only two levels. Set 'hue' will show us split violin plots.
matkey: ``str``, optional, default: ``None``
If matkey is set, select matrix with matkey as keyword in the current modality. Only works for MultimodalData or UnimodalData objects.
stripplot: ``bool``, optional, default: ``False``
Attach a stripplot to the violinplot or not. This option will be automatically turn off if 'hue' is set.
inner: ``str``, optional, default: ``None``
Representation of the datapoints in the violin interior:
- If ``box``, draw a miniature boxplot.
- If ``quartiles``, draw the quartiles of the distribution.
- If ``point`` or ``stick``, show each underlying datapoint.
- If ``None``, will draw unadorned violins.
scale: ``str``, optional, default: ``width``
The method used to scale the width of each violin:
- If ``width``, each violin will have the same width.
- If ``area``, each violin will have the same area.
- If ``count``, the width of the violins will be scaled by the number of observations in that bin.
panel_size: ``Tuple[float, float]``, optional, default: ``(8, 0.5)``
The size (width, height) in inches of each violin panel.
palette: ``List[str]``, optional (default: ``None``)
Used for setting colors for categories in ``groupby``. Within the list, each string is the color for one category.
left: ``float``, optional, default: ``0.15``
This parameter sets the figure's left margin as a fraction of panel's width (left * panel_size[0]).
bottom: ``float``, optional, default: ``0.15``
This parameter sets the figure's bottom margin as a fraction of panel's height (bottom * panel_size[1]).
wspace: ``float``, optional, default: ``0.1``
This parameter sets the width between panels and also the figure's right margin as a fraction of panel's width (wspace * panel_size[0]).
ylabel: ``str``, optional, default: ``None``
Y-axis label. No label to show if ``None``.
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: ``300.0``
The resolution in dots per inch.
kwargs
Are passed to ``seaborn.violinplot``.
Returns
-------
``Figure`` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``show == False``
Examples
--------
>>> pg.violin(data, attrs=['CD14', 'TRAC', 'CD34'], groupby='louvain_labels')
"""
if not is_list_like(attrs):
attrs = [attrs]
if not isinstance(data, anndata.AnnData):
cur_matkey = data.current_matrix()
if matkey is not None:
assert not isinstance(data, anndata.AnnData)
data.select_matrix(matkey)
nrows = len(attrs)
fig, axes = _get_subplot_layouts(nrows=nrows, ncols=1, panel_size=panel_size, dpi=dpi, left=left, bottom=bottom, wspace=wspace, hspace=0, squeeze=False, sharey=False)
obs_keys = []
genes = []
for key in attrs:
if key in data.obs:
assert is_numeric_dtype(data.obs[key])
obs_keys.append(key)
else:
if key not in data.var_names:
logger.warning(f"Cannot find gene {key}. Please make sure all genes are included in data.var_names before running this function!")
return None
genes.append(key)
df_list = [pd.DataFrame({"label": data.obs[groupby].values})]
if hue is not None:
df_list.append(pd.DataFrame({hue: data.obs[hue].values}))
stripplot = False
if len(obs_keys) > 0:
df_list.append(data.obs[obs_keys].reset_index(drop=True))
if len(genes) > 0:
expr_mat = slicing(data[:, genes].X)
df_list.append(pd.DataFrame(data=expr_mat, columns=genes))
df = pd.concat(df_list, axis = 1)
for i in range(nrows):
ax = axes[i, 0]
if stripplot:
sns.stripplot(x="label", y=attrs[i], hue = hue, data=df, ax=ax, size=1, color="k", jitter=True)
sns.violinplot(x="label", y=attrs[i], hue = hue, data=df, inner=inner, linewidth=1, ax=ax, cut=0, scale=scale, split=True, palette=palette, **kwargs)
ax.grid(False)
if hue is not None:
if i == 0:
ax.legend(loc="center left", bbox_to_anchor=(1.02, 0.5))
else:
ax.get_legend().set_visible(False)
if i < nrows - 1:
ax.set_xlabel("")
else:
ax.set_xlabel(groupby)
ax.set_xticklabels(ax.get_xticklabels(), rotation=90)
ax.set_ylabel(attrs[i], labelpad=8, rotation=0, horizontalalignment='right', fontsize='medium')
ax.tick_params(axis='y', right=True, left=False, labelright=True, labelleft=False, labelsize='small')
if ylabel is not None:
fig.text(0.02, 0.5, ylabel, rotation="vertical", fontsize="xx-large")
# Reset current matrix if needed.
if not isinstance(data, anndata.AnnData):
if data.current_matrix() != cur_matkey:
data.select_matrix(cur_matkey)
return fig if return_fig else None
def heatmap(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
attrs: Union[str, List[str]],
groupby: str,
matkey: Optional[str] = None,
on_average: bool = True,
switch_axes: bool = False,
attrs_cluster: Optional[bool] = False,
attrs_dendrogram: Optional[bool] = True,
groupby_cluster: Optional[bool] = True,
groupby_dendrogram: Optional[bool] = True,
attrs_labelsize: Optional[float] = 10.0,
groupby_labelsize: Optional[float] = 10.0,
cbar_labelsize: Optional[float] = 10.0,
panel_size: Tuple[float, float] = (10, 10),
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
**kwargs,
) -> Union[plt.Figure, None]:
"""
Generate a heatmap.
Parameters
-----------
data: ``AnnData`` or ``MultimodalData`` or ``UnimodalData`` object
Single-cell expression data.
attrs: ``str`` or ``List[str]``
Cell attributes or features to plot.
Cell attributes must exist in ``data.obs`` and must be numeric.
Features must exist in ``data.var``.
By default, attrs are plotted as columns.
groupby: ``str``
A categorical variable in data.obs that is used to categorize the cells, e.g. Clusters.
By default, data.obs['groupby'] is plotted as rows.
matkey: ``str``, optional, default: ``None``
If matkey is set, select matrix with matkey as keyword in the current modality. Only works for MultimodalData or UnimodalData objects.
on_average: ``bool``, optional, default: ``True``
If ``True``, plot cluster average gene expression (i.e. show a Matrixplot); otherwise, plot a general heatmap.
switch_axes: ``bool``, optional, default: ``False``
By default, X axis is for attributes, and Y axis for clusters. If this parameter is ``True``, switch the axes.
Moreover, with ``on_average`` being ``False``, if ``switch_axes`` is ``False``, ``row_cluster`` is enforced to be ``False``; if ``switch_axes`` is ``True``, ``col_cluster`` is enforced to be ``False``.
attrs_cluster: ``bool``, optional, default: ``False``
Cluster attributes and generate a attribute-wise dendrogram.
attrs_dendrogram: ``bool``, optional, default: ``True``
Only matters if attrs_cluster is True. Show the dendrogram if this option is True.
groupby_cluster: ``bool``, optional, default: ``True``
Cluster data.obs['groupby'] and generate a cluster-wise dendrogram.
groupby_dendrogram: ``bool``, optional, default: ``True``
Only matters if groupby_cluster is True. Show the dendrogram if this option is True.
attrs_labelsize: ``float``, optional, default: 10.0
Fontsize for labels of attrs.
groupby_labelsize: ``float``, optional, default: 10.0
Fontsize for labels of data.obs['groupby'].
cbar_labelsize: ``float``, optional, default: 10.0
Fontsize of the color bar.
panel_size: ``Tuple[float, float]``, optional, default: ``(10, 10)``
Overall size of the heatmap in ``(width, height)`` form.
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: ``300.0``
The resolution in dots per inch.
kwargs
Are passed to ``seaborn.heatmap``.
.. _colormap documentation: https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html
Returns
-------
``Figure`` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``return_fig == True``
Examples
--------
>>> pg.heatmap(data, genes=['CD14', 'TRAC', 'CD34'], groupby='louvain_labels')
"""
if not isinstance(data, anndata.AnnData):
cur_matkey = data.current_matrix()
if matkey is not None:
assert not isinstance(data, anndata.AnnData)
data.select_matrix(matkey)
if isinstance(attrs, str):
attrs = [attrs]
obs_keys = []
genes = []
for key in attrs:
if key in data.obs:
assert is_numeric_dtype(data.obs[key])
obs_keys.append(key)
else:
if key not in data.var_names:
logger.warning(f"Cannot find gene {key}. Please make sure all genes are included in data.var_names before running this function!")
return None
genes.append(key)
clusters = data.obs[groupby].values
if not is_categorical_dtype(clusters):
clusters = pd.Categorical(clusters)
else:
clusters = clusters.remove_unused_categories()
df_list = [pd.DataFrame({'cluster_name': clusters})]
if len(obs_keys) > 0:
df_list.append(data.obs[obs_keys].reset_index(drop=True))
if len(genes) > 0:
expr_mat = slicing(data[:, genes].X)
df_list.append(pd.DataFrame(data=expr_mat, columns=genes))
df = pd.concat(df_list, axis = 1)
attr_names = df.columns[1:].values
if on_average:
if not 'cmap' in kwargs.keys():
kwargs['cmap'] = 'Reds'
df = df.groupby('cluster_name').mean()
cluster_ids = df.index
else:
cluster_ids = df.pop('cluster_name').values
if not groupby_cluster:
idx = cluster_ids.argsort(kind = 'mergesort')
df = df.iloc[idx, :] # organize df by category order
cluster_ids = cluster_ids[idx]
cell_colors = np.zeros(df.shape[0], dtype=object)
palette = _get_palette(cluster_ids.categories.size)
for k, cat in enumerate(cluster_ids.categories):
cell_colors[cluster_ids == cat] = palette[k]
if not switch_axes:
cg = sns.clustermap(
data=df,
row_colors=cell_colors if not on_average else None,
col_colors=None,
row_cluster=groupby_cluster,
col_cluster=attrs_cluster,
linewidths=0,
yticklabels=cluster_ids if on_average else [],
xticklabels=attr_names,
figsize=panel_size,
**kwargs,
)
cg.ax_heatmap.set_ylabel("")
if attrs_labelsize is not None:
cg.ax_heatmap.tick_params(axis='x', labelsize=attrs_labelsize, labelrotation=75)
else:
cg = sns.clustermap(
data=df.T,
row_colors=None,
col_colors=cell_colors if not on_average else None,
row_cluster=attrs_cluster,
col_cluster=groupby_cluster,
linewidths=0,
yticklabels=attr_names,
xticklabels=cluster_ids if on_average else [],
figsize=panel_size,
**kwargs,
)
cg.ax_heatmap.set_xlabel("")
if attrs_labelsize is not None:
cg.ax_heatmap.tick_params(axis='y', labelsize=attrs_labelsize)
show_row_dendrogram = (attrs_cluster and attrs_dendrogram) if switch_axes else (groupby_cluster and groupby_dendrogram)
show_col_dendrogram = (groupby_cluster and groupby_dendrogram) if switch_axes else (attrs_cluster and attrs_dendrogram)
if show_row_dendrogram:
cg.ax_heatmap.yaxis.tick_right()
cg.ax_row_dendrogram.set_visible(True)
# Avoid overlap of colorbar and row dendrogram.
color_box = cg.ax_cbar.get_position()
square_plot = cg.ax_heatmap.get_position()
if square_plot.y1 > color_box.y0:
y_diff = square_plot.y1 - color_box.y0
color_box.y0 = square_plot.y1
color_box.y1 += y_diff
cg.ax_cbar.set_position(color_box)
else:
cg.ax_heatmap.yaxis.tick_left()
cg.ax_row_dendrogram.set_visible(False)
# Move the colorbar to the right-side.
color_box = cg.ax_heatmap.get_position()
color_box.x0 = color_box.x1 + 0.04
color_box.x1 = color_box.x0 + 0.02
cg.ax_cbar.set_position(color_box)
cg.ax_cbar.yaxis.set_ticks_position("right")
if show_col_dendrogram:
cg.ax_heatmap.xaxis.tick_bottom()
cg.ax_col_dendrogram.set_visible(True)
else:
cg.ax_heatmap.xaxis.tick_top()
cg.ax_col_dendrogram.set_visible(False)
cg.ax_cbar.tick_params(labelsize=cbar_labelsize)
cg.fig.dpi = dpi
if not on_average:
if groupby_cluster:
from matplotlib.patches import Patch
legend_elements = [Patch(color = color, label = label) for color, label in zip(palette, cluster_ids.categories)]
cg.ax_heatmap.legend(handles=legend_elements, loc='lower left', bbox_to_anchor = (1.02, 1.02), fontsize = groupby_labelsize)
else:
values = cluster_ids.value_counts().values
ticks = np.cumsum(values) - values / 2
labels = cluster_ids.categories
if not switch_axes:
cg.ax_row_colors.yaxis.tick_left()
cg.ax_row_colors.set_yticks(ticks)
cg.ax_row_colors.set_yticklabels(labels)
cg.ax_row_colors.tick_params(axis='y', left = False, length=10)
else:
cg.ax_col_colors.xaxis.tick_top()
cg.ax_col_colors.set_xticks(ticks)
cg.ax_col_colors.set_xticklabels(labels, rotation=45)
cg.ax_col_colors.tick_params(axis='x', top = False, labelsize = groupby_labelsize, length=10)
if not isinstance(data, anndata.AnnData):
if cur_matkey != data.current_matrix():
data.select_matrix(cur_matkey)
return cg.fig if return_fig else None
def dotplot(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
genes: Union[str, List[str]],
groupby: str,
reduce_function: Callable[[np.ndarray], float] = np.mean,
fraction_min: float = 0,
fraction_max: float = None,
dot_min: int = 0,
dot_max: int = 20,
switch_axes: bool = False,
cmap: Union[str, List[str], Tuple[str]] = 'Reds',
sort_function: Union[Callable[[List[str]], List[str]], str] = 'natsorted',
grid: bool = True,
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
**kwds,
) -> Union[plt.Figure, None]:
"""
Generate a dot plot.
Parameters
----------
data: ``AnnData`` or ``UnimodalData`` or ``MultimodalData`` object
Single cell expression data.
genes: ``str`` or ``List[str]``
Features to plot.
groupby: ``str``
A categorical variable in data.obs that is used to categorize the cells, e.g. Clusters.
reduce_function: ``Callable[[np.ndarray], float]``, optional, default: ``np.mean``
Function to calculate statistic on expression data. Default is mean.
fraction_min: ``float``, optional, default: ``0``.
Minimum fraction of expressing cells to consider.
fraction_max: ``float``, optional, default: ``None``.
Maximum fraction of expressing cells to consider. If ``None``, use the maximum value from data.
dot_min: ``int``, optional, default: ``0``.
Minimum size in pixels for dots.
dot_max: ``int``, optional, default: ``20``.
Maximum size in pixels for dots.
switch_axes: ``bool``, optional, default: ``False``.
If ``True``, switch X and Y axes.
cmap: ``str`` or ``List[str]`` or ``Tuple[str]``, optional, default: ``Reds``
Color map.
sort_function: ``Union[Callable[List[str], List[str]], str]``, optional, default: ``natsorted``
Function used for sorting groupby labels. If ``natsorted``, apply natsorted function to sort by natural order. If ``None``, don't sort. Otherwise, a callable function will be applied to the labels for sorting.
grid: ``bool``, optional, default: ``True``
If ``True``, plot grids.
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: ``300.0``
The resolution in dots per inch.
**kwds:
Are passed to ``matplotlib.pyplot.scatter``.
Returns
-------
``Figure`` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``return_fig == True``
Examples
--------
>>> pg.dotplot(data, genes = ['CD14', 'TRAC', 'CD34'], groupby = 'louvain_labels')
"""
sns.set(font_scale=0.7, style='whitegrid')
if not is_list_like(genes):
geness = [genes]
keywords = dict(cmap=cmap)
keywords.update(kwds)
from scipy.sparse import issparse
X = slicing(data[:, genes].X)
df = pd.DataFrame(data=X, columns=genes)
df[groupby] = data.obs[groupby].values
if df[groupby].isna().sum() > 0:
logger.warning(f"Detected NaN values in attribute '{groupby}'! Please check if '{groupby}' is set correctly.")
return None
series = df[groupby].value_counts()
idx = series == 0
if idx.sum() > 0:
logger.warning(f"The following categories contain no cells and are removed: {','.join(list(series.index[idx]))}.")
df[groupby] = df[groupby].cat.remove_unused_categories()
def non_zero(g):
return np.count_nonzero(g) / g.shape[0]
summarized_df = df.groupby(groupby).aggregate([reduce_function, non_zero])
row_indices = summarized_df.index.tolist()
if sort_function == "natsorted":
row_indices = natsorted(row_indices)
elif callable(sort_function):
row_indices = sort_function(row_indices)
row_indices.reverse()
summarized_df = summarized_df.loc[row_indices]
mean_columns = []
frac_columns = []
for j in range(len(summarized_df.columns)):
if j % 2 == 0:
mean_columns.append(summarized_df.columns[j])
else:
frac_columns.append(summarized_df.columns[j])
# Genes on columns, groupby on rows
fraction_df = summarized_df[frac_columns]
mean_df = summarized_df[mean_columns]
y, x = np.indices(mean_df.shape)
y = y.flatten()
x = x.flatten()
fraction = fraction_df.values.flatten()
if fraction_max is None:
fraction_max = fraction.max()
pixels = _get_dot_size(fraction, fraction_min, fraction_max, dot_min, dot_max)
summary_values = mean_df.values.flatten()
xlabel = [genes[i] for i in range(len(genes))]
ylabel = [str(summarized_df.index[i]) for i in range(len(summarized_df.index))]
xticks = genes
yticks = summarized_df.index.map(str).values
if switch_axes:
x, y = y, x
xlabel, ylabel = ylabel, xlabel
xticks, yticks = yticks, xticks
dotplot_df = pd.DataFrame(data=dict(x=x, y=y, value=summary_values, pixels=pixels, fraction=fraction,
xlabel=np.array(xlabel)[x], ylabel=np.array(ylabel)[y]))
import matplotlib.gridspec as gridspec
width = int(np.ceil(((dot_max + 1) + 4) * len(xticks) + dotplot_df['ylabel'].str.len().max()) + dot_max + 100)
height = int(np.ceil(((dot_max + 1) + 4) * len(yticks) + dotplot_df['xlabel'].str.len().max()) + 50)
fig = plt.figure(figsize=(1.1 * width / 100.0, height / 100.0), dpi=dpi)
gs = gridspec.GridSpec(3, 11, figure = fig)
# Main plot
mainplot_col_grid = -2 if len(xlabel) < 10 else -1
ax = fig.add_subplot(gs[:, :mainplot_col_grid])
sc = ax.scatter(x='x', y='y', c='value', s='pixels', data=dotplot_df, linewidth=0.5, edgecolors='black', **keywords)
ax.spines["top"].set_color('black')
ax.spines["bottom"].set_color('black')
ax.spines["left"].set_color('black')
ax.spines["right"].set_color('black')
if not grid:
ax.grid(False)
if not switch_axes:
ax.set_ylabel(str(groupby))
ax.set_xlabel('')
else:
ax.set_ylabel('')
ax.set_xlabel(str(groupby))
ax.set_xlim(-1, len(xticks))
ax.set_ylim(-1, len(yticks))
ax.set_xticks(range(len(xticks)))
ax.set_xticklabels(xticks)
ax.set_yticks(range(len(yticks)))
ax.set_yticklabels(yticks)
plt.xticks(rotation=90)
cbar = plt.colorbar(sc)
#cbar.set_label("Mean of\nexpressing cells")
size_range = fraction_max - fraction_min
if 0.3 < size_range <= 0.6:
size_legend_step = 0.1
elif size_range <= 0.3:
size_legend_step = 0.05
else:
size_legend_step = 0.2
size_ticks = np.arange(fraction_min if fraction_min > 0 or fraction_min > 0 else fraction_min + size_legend_step,
fraction_max + size_legend_step, size_legend_step)
legend_row_grid = 1 if height / 3 > 100 else 3
ax2 = gridspec.GridSpecFromSubplotSpec(1, 1, subplot_spec=gs[0:legend_row_grid, -1])
size_legend = fig.add_subplot(ax2[0])
size_tick_pixels = _get_dot_size(size_ticks, fraction_min, fraction_max, dot_min, dot_max)
size_tick_labels = ["{:.0%}".format(x) for x in size_ticks]
size_legend.scatter(x=np.repeat(0, len(size_ticks)), y=np.arange(0, len(size_ticks)), s=size_tick_pixels, c='black', linewidth=0.5)
size_legend.title.set_text("Fraction of\nexpressing cells")
size_legend.set_xlim(-0.1, 0.1)
size_legend.set_xticks([])
ymin, ymax = size_legend.get_ylim()
size_legend.set_ylim(ymin, ymax + 0.5)
size_legend.set_yticks(np.arange(len(size_ticks)))
size_legend.set_yticklabels(size_tick_labels)
size_legend.tick_params(axis='y', labelleft=False, labelright=True)
size_legend.spines["top"].set_visible(False)
size_legend.spines["bottom"].set_visible(False)
size_legend.spines["left"].set_visible(False)
size_legend.spines["right"].set_visible(False)
size_legend.grid(False)
# Reset global settings.
sns.reset_orig()
return fig if return_fig else None
def dendrogram(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
groupby: str,
rep: str = 'pca',
genes: Optional[List[str]] = None,
correlation_method: str = 'pearson',
n_clusters: Optional[int] = None,
affinity: str = 'euclidean',
linkage: str = 'complete',
compute_full_tree: Union[str, bool] = 'auto',
distance_threshold: Optional[float] = 0,
panel_size: Tuple[float, float] = (6, 6),
orientation: str = 'top',
color_threshold: Optional[float] = None,
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
**kwargs,
) -> Union[plt.Figure, None]:
"""
Generate a dendrogram on hierarchical clustering result.
The metrics used here are consistent with SCANPY's dendrogram_ implementation.
*scikit-learn* `Agglomerative Clustering`_ implementation is used for hierarchical clustering.
.. _dendrogram: https://scanpy.readthedocs.io/en/stable/api/scanpy.tl.dendrogram.html
.. _Agglomerative Clustering: https://scikit-learn.org/stable/modules/generated/sklearn.cluster.AgglomerativeClustering.html
Parameters
----------
data: ``MultimodalData``, ``UnimodalData``, or ``AnnData`` object
Single cell expression data.
genes: ``List[str]``, optional, default: ``None``
List of genes to use. Gene names must exist in ``data.var``. If set, use the counts in ``data.X`` for plotting; if set as ``None``, use the embedding specified in ``rep`` for plotting.
rep: ``str``, optional, default: ``pca``
Cell embedding to use. It only works when ``genes``is ``None``, and its key ``"X_"+rep`` must exist in ``data.obsm``. By default, use PCA coordinates.
groupby: ``str``
Categorical cell attribute to plot, which must exist in ``data.obs``.
correlation_method: ``str``, optional, default: ``pearson``
Method of correlation between categories specified in ``data.obs``. Available options are: ``pearson``, ``kendall``, ``spearman``. See `pandas corr documentation <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.corr.html>`_ for details.
n_clusters: ``int``, optional, default: ``None``
The number of clusters to find, used by hierarchical clustering. It must be ``None`` if ``distance_threshold`` is not ``None``.
affinity: ``str``, optional, default: ``correlation``
Metric used to compute the linkage, used by hierarchical clustering. Valid values for metric are:
- From scikit-learn: ``cityblock``, ``cosine``, ``euclidean``, ``l1``, ``l2``, ``manhattan``.
- From scipy.spatial.distance: ``braycurtis``, ``canberra``, ``chebyshev``, ``correlation``, ``dice``, ``hamming``, ``jaccard``, ``kulsinski``, ``mahalanobis``, ``minkowski``, ``rogerstanimoto``, ``russellrao``, ``seuclidean``, ``sokalmichener``, ``sokalsneath``, ``sqeuclidean``, ``yule``.
Default is the correlation distance. See `scikit-learn distance documentation <https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html>`_ for details.
linkage: ``str``, optional, default: ``complete``
Which linkage criterion to use, used by hierarchical clustering. Below are available options:
- ``ward`` minimizes the variance of the clusters being merged.
- ``avarage`` uses the average of the distances of each observation of the two sets.
- ``complete`` uses the maximum distances between all observations of the two sets. (Default)
- ``single`` uses the minimum of the distances between all observations of the two sets.
See `scikit-learn documentation <https://scikit-learn.org/stable/modules/generated/sklearn.cluster.AgglomerativeClustering.html>`_ for details.
compute_full_tree: ``str`` or ``bool``, optional, default: ``auto``
Stop early the construction of the tree at ``n_clusters``, used by hierarchical clustering. It must be ``True`` if ``distance_threshold`` is not ``None``.
By default, this option is ``auto``, which is ``True`` if and only if ``distance_threshold`` is not ``None``, or ``n_clusters`` is less than ``min(100, 0.02 * n_groups)``, where ``n_groups`` is the number of categories in ``data.obs[groupby]``.
distance_threshold: ``float``, optional, default: ``0``
The linkage distance threshold above which, clusters will not be merged. If not ``None``, ``n_clusters`` must be ``None`` and ``compute_full_tree`` must be ``True``.
panel_size: ``Tuple[float, float]``, optional, default: ``(6, 6)``
The size (width, height) in inches of figure.
orientation: ``str``, optional, default: ``top``
The direction to plot the dendrogram. Available options are: ``top``, ``bottom``, ``left``, ``right``. See `scipy dendrogram documentation`_ for explanation.
color_threshold: ``float``, optional, default: ``None``
Threshold for coloring clusters. See `scipy dendrogram documentation <https://docs.scipy.org/doc/scipy/reference/generated/scipy.cluster.hierarchy.dendrogram.html>`_ for explanation.
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: ``300.0``
The resolution in dots per inch.
**kwargs:
Are passed to ``scipy.cluster.hierarchy.dendrogram``.
Returns
-------
``Figure`` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``return_fig == True``
Examples
--------
>>> pg.dendrogram(data, genes=data.var_names, groupby='louvain_labels')
>>> pg.dendrogram(data, rep='pca', groupby='louvain_labels')
"""
if genes is None:
embed_df = pd.DataFrame(X_from_rep(data, rep))
embed_df.set_index(data.obs[groupby], inplace=True)
else:
X = slicing(data[:, genes].X)
embed_df = pd.DataFrame(X)
embed_df.set_index(data.obs[groupby], inplace=True)
mean_df = embed_df.groupby(level=0).mean()
mean_df.index = mean_df.index.astype('category')
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram
corr_mat = mean_df.T.corr(method=correlation_method)
clusterer = AgglomerativeClustering(
n_clusters=n_clusters,
affinity=affinity,
linkage=linkage,
compute_full_tree=compute_full_tree,
distance_threshold=distance_threshold
)
clusterer.fit(corr_mat)
counts = np.zeros(clusterer.children_.shape[0])
n_samples = len(clusterer.labels_)
for i, merge in enumerate(clusterer.children_):
current_count = 0
for child_idx in merge:
if child_idx < n_samples:
current_count += 1 # Leaf node
else:
current_count += counts[child_idx - n_samples]
counts[i] = current_count
linkage_matrix = np.column_stack([clusterer.children_, clusterer.distances_, counts]).astype(float)
fig, ax = _get_subplot_layouts(panel_size=panel_size, dpi=dpi)
dendrogram(linkage_matrix, labels=mean_df.index.categories, ax=ax, **kwargs)
plt.xticks(rotation=90, fontsize=10)
plt.tight_layout()
return fig if return_fig else None
def hvfplot(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
top_n: int = 20,
panel_size: Optional[Tuple[float, float]] = (6, 4),
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
) -> Union[plt.Figure, None]:
"""
Generate highly variable feature plot.
Only works for HVGs returned by ``highly_variable_features`` method with ``flavor=='pegasus'``.
Parameters
-----------
data: ``MultimodalData``, ``UnimodalData``, or ``anndata.AnnData`` object.
Single cell expression data.
top_n: ``int``, optional, default: ``20``
Number of top highly variable features to show names.
panel_size: ``Tuple[float, float]``, optional, default: ``(6, 4)``
The size (width, height) in inches of figure.
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: ``300.0``
The resolution in dots per inch.
Returns
--------
``Figure`` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``return_fig == True``
Examples
---------
>>> pg.hvfplot(data)
>>> pg.hvfplot(data, top_n=10, dpi=150)
"""
robust_idx = data.var["robust"].values
x = data.var.loc[robust_idx, "mean"]
y = data.var.loc[robust_idx, "var"]
fitted = data.var.loc[robust_idx, "hvf_loess"]
hvg_index = data.var.loc[robust_idx, "highly_variable_features"]
hvg_rank = data.var.loc[robust_idx, "hvf_rank"]
gene_symbols = data.var_names[robust_idx]
fig, ax = _get_subplot_layouts(panel_size=panel_size, dpi=dpi)
ax.scatter(x[hvg_index], y[hvg_index], s=5, c='b', marker='o', linewidth=0.5, alpha=0.5, label='highly variable features')
ax.scatter(x[~hvg_index], y[~hvg_index], s=5, c='k', marker='o', linewidth=0.5, alpha=0.5, label = 'other features')
ax.legend(loc = 'best', fontsize = 5)
ax.set_xlabel("Mean log expression")
ax.set_ylabel("Variance of log expression")
order = x.argsort().values
ax.plot(x[order], fitted[order], "r-", linewidth=1)
ord_rank = hvg_rank.argsort().values
texts = []
for i in range(top_n):
pos = ord_rank[i]
texts.append(ax.text(x[pos], y[pos], gene_symbols[pos], fontsize=5))
from adjustText import adjust_text
adjust_text(texts, arrowprops=dict(arrowstyle='-', color='k', lw=0.5))
return fig if return_fig else None
def qcviolin(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
plot_type: str,
min_genes_before_filt: Optional[int] = 100,
n_violin_per_panel: Optional[int] = 8,
panel_size: Optional[Tuple[float, float]] = (6, 4),
left: Optional[float] = 0.2,
bottom: Optional[float] = 0.15,
wspace: Optional[float] = 0.3,
hspace: Optional[float] = 0.35,
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
) -> Union[plt.Figure, None]:
"""
Plot quality control statistics (before filtration vs. after filtration) as violin plots. Require statistics such as "n_genes", "n_counts" and "percent_mito" precomputed.
Parameters
-----------
data: ``MultimodalData``, ``UnimodalData``, or ``anndata.AnnData`` object.
Single cell expression data.
plot_type: ``str``
Choose from ``gene``, ``count`` and ``mito``, which shows number of expressed genes, number of UMIs and percentage of mitochondrial rate.
min_genes_before_filt: ``int``, optional, default: 100
If data loaded are raw data (i.e. min(n_genes) == 0), filter out cell barcodes with less than ``min_genes_before_filt`` for better visual effects.
n_violin_per_panel: ``int``, optional, default: 8
Number of violin plots (samples) shown in one panel.
panel_size: `tuple`, optional (default: `(6, 4)`)
The panel size (width, height) in inches.
left: `float`, optional (default: `0.2`)
This parameter sets the figure's left margin as a fraction of panel's width (left * panel_size[0]).
bottom: `float`, optional (default: `0.15`)
This parameter sets the figure's bottom margin as a fraction of panel's height (bottom * panel_size[1]).
wspace: `float`, optional (default: `0.4`)
This parameter sets the width between panels and also the figure's right margin as a fraction of panel's width (wspace * panel_size[0]).
hspace: `float`, optional (defualt: `0.15`)
This parameter sets the height between panels and also the figure's top margin as a fraction of panel's height (hspace * panel_size[1]).
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: ``300.0``
The resolution in dots per inch.
Returns
--------
``Figure`` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``return_fig == True``
Examples
---------
>>> pg.qcviolin(data, "mito", dpi = 500)
"""
pt2attr = {"gene": "n_genes", "count": "n_counts", "mito": "percent_mito"}
pt2ylab = {
"gene": "Number of expressed genes",
"count": "Number of UMIs",
"mito": "Percentage of mitochondrial UMIs",
}
if "df_qcplot" not in data.uns:
if "Channel" not in data.obs:
data.obs["Channel"] = pd.Categorical([""] * data.shape[0])
target_cols = np.array(["Channel", "n_genes", "n_counts", "percent_mito"])
target_cols = target_cols[np.isin(target_cols, data.obs.columns)]
df = data.obs[data.obs["n_genes"] >= min_genes_before_filt] if data.obs["n_genes"].min() == 0 else data.obs
df_plot_before = df[target_cols].copy()
df_plot_before.reset_index(drop=True, inplace=True)
df_plot_before["status"] = "original"
df_plot_after = data.obs.loc[data.obs["passed_qc"], target_cols].copy()
df_plot_after.reset_index(drop=True, inplace=True)
df_plot_after["status"] = "filtered"
df_qcplot = pd.concat((df_plot_before, df_plot_after), axis=0)
df_qcplot["status"] = pd.Categorical(df_qcplot["status"].values, categories = ["original", "filtered"])
df_qcplot["Channel"] = pd.Categorical(df_qcplot["Channel"].values, categories = natsorted(df_qcplot["Channel"].astype(str).unique()))
data.uns["df_qcplot"] = df_qcplot
df_qcplot = data.uns["df_qcplot"]
if pt2attr[plot_type] not in df_qcplot:
logger.warning(f"Cannot find qc metric {pt2attr[plot_type]}!")
return None
channels = df_qcplot["Channel"].cat.categories
n_channels = channels.size
n_pannels = (n_channels - 1) // n_violin_per_panel + 1
nrows = ncols = None
nrows, ncols = _get_nrows_and_ncols(n_pannels, nrows, ncols)
fig, axes = _get_subplot_layouts(nrows=nrows, ncols=ncols, panel_size=panel_size, dpi=dpi, left=left, bottom=bottom, wspace=wspace, hspace=hspace, sharex = False, sharey = False, squeeze=False)
for i in range(nrows):
for j in range(ncols):
ax = axes[i, j]
ax.grid(False)
panel_no = i * ncols + j
if panel_no < n_pannels:
start = panel_no * n_violin_per_panel
end = min(start + n_violin_per_panel, n_channels)
idx = np.isin(df_qcplot["Channel"], channels[start:end])
if start == 0 and end == n_channels:
df_plot = df_qcplot
else:
df_plot = df_qcplot[idx].copy()
df_plot["Channel"] = pd.Categorical(df_plot["Channel"].values, categories = natsorted(channels[start:end]))
sns.violinplot(
x="Channel",
y=pt2attr[plot_type],
hue="status",
data=df_plot,
split=True,
linewidth=0.5,
cut=0,
inner=None,
ax = ax,
)
ax.set_xlabel("Channel")
ax.set_ylabel(pt2ylab[plot_type])
ax.legend(loc="upper right", fontsize=8)
if max([len(x) for x in channels[start:end]]) >= 5:
ax.set_xticklabels(ax.get_xticklabels(), fontsize=8, rotation=-45)
else:
ax.set_frame_on(False)
ax.set_xticks([])
ax.set_yticks([])
return fig if return_fig else None
def volcano(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
cluster_id: str,
de_key: str = "de_res",
de_test: str = 'mwu',
qval_threshold: float = 0.05,
log2fc_threshold: float = 1.0,
top_n: int = 20,
panel_size: Optional[Tuple[float, float]] = (6, 4),
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
) -> Union[plt.Figure, None]:
"""
Generate Volcano plots (-log10 p value vs. log2 fold change) for visualizing DE results.
Parameters
-----------
data: ``MultimodalData``, ``UnimodalData``, or ``anndata.AnnData`` object.
Single cell expression data.
cluster_id: ``str``
Cluster ID for the cluster we want to show DE results. There are two cases:
* If ``condition`` is ``None`` in ``pg.de_analysis``: Just specify one cluster
label in the cluster attribute used in ``pg.de_analysis``.
* If ``condition`` is not ``None`` in ``pg.de_analysis``: Specify cluster ID in
this format: **"cluster_label:cond_level"**, where **cluster_label** is the
cluster label, and **cond_level** is the condition ID. And this shows result of
cells within the cluster under the specific condition.
de_key: ``str``, optional, default: ``de_res``
The varm keyword for DE results. data.varm[de_key] should store the full DE result table.
de_test: ``str``, optional, default: ``mwu``
Which DE test results to show. Use MWU test result by default.
qval_threshold: ``float``, optional, default: 0.05.
Selected FDR rate. A horizontal line indicating this rate will be shown in the figure.
log2fc_threshold: ``float``, optional, default: 1.0
Log2 fold change threshold to highlight biologically interesting genes. Two vertical lines representing negative and positive log2 fold change will be shown.
top_n: ``int``, optional, default: ``20``
Number of top DE genes to show names. Genes are ranked by Log2 fold change.
panel_size: ``Tuple[float, float]``, optional, default: ``(6, 4)``
The size (width, height) in inches of figure.
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: ``300.0``
The resolution in dots per inch.
Returns
--------
``Figure`` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``return_fig == True``
Examples
---------
>>> pg.volcano(data, cluster_id = '1', dpi=200)
"""
if de_key not in data.varm:
logger.warning(f"Cannot find DE results '{de_key}'. Please conduct DE analysis first!")
return None
de_res = data.varm[de_key]
fcstr = f"{cluster_id}:log2FC"
pstr = f"{cluster_id}:{de_test}_pval"
qstr = f"{cluster_id}:{de_test}_qval"
columns = de_res.dtype.names
if (fcstr not in columns) or (pstr not in columns) or (qstr not in columns):
logger.warning(f"Please conduct DE test {de_test} first!")
return None
log2fc = de_res[fcstr]
pvals = de_res[pstr]
pvals[pvals == 0.0] = 1e-45 # very small pvalue to avoid log10 0
neglog10p = -np.log10(pvals)
yconst = min(neglog10p[de_res[qstr] <= qval_threshold])
fig, ax = _get_subplot_layouts(panel_size=panel_size, dpi=dpi)
idxsig = neglog10p >= yconst
idxnsig = neglog10p < yconst
idxfc = (log2fc <= -log2fc_threshold) | (log2fc >= log2fc_threshold)
idxnfc = ~idxfc
idx = idxnsig & idxnfc
ax.scatter(log2fc[idx], neglog10p[idx], s=5, c='k', marker='o', linewidths=0.5, alpha=0.5, label="NS")
idx = idxnsig & idxfc
ax.scatter(log2fc[idx], neglog10p[idx], s=5, c='g', marker='o', linewidths=0.5, alpha=0.5, label=r"Log$_2$ FC")
idx = idxsig & idxnfc
ax.scatter(log2fc[idx], neglog10p[idx], s=5, c='b', marker='o', linewidths=0.5, alpha=0.5, label=r"q-value")
idx = idxsig & idxfc
ax.scatter(log2fc[idx], neglog10p[idx], s=5, c='r', marker='o', linewidths=0.5, alpha=0.5, label=r"q-value and log$_2$ FC")
ax.set_xlabel(r"Log$_2$ fold change")
ax.set_ylabel(r"$-$Log$_{10}$ $P$")
legend = ax.legend(
loc="center",
bbox_to_anchor=(0.5, 1.1),
frameon=False,
fontsize=8,
ncol=4,
)
for handle in legend.legendHandles: # adjust legend size
handle.set_sizes([50.0])
ax.axhline(y = yconst, c = 'k', lw = 0.5, ls = '--')
ax.axvline(x = -log2fc_threshold, c = 'k', lw = 0.5, ls = '--')
ax.axvline(x = log2fc_threshold, c = 'k', lw = 0.5, ls = '--')
texts = []
idx = np.where(idxsig & (log2fc >= log2fc_threshold))[0]
posvec = np.argsort(log2fc[idx])[::-1][0:top_n]
for pos in posvec:
gid = idx[pos]
texts.append(ax.text(log2fc[gid], neglog10p[gid], data.var_names[gid], fontsize=5))
idx = np.where(idxsig & (log2fc <= -log2fc_threshold))[0]
posvec = np.argsort(log2fc[idx])[0:top_n]
for pos in posvec:
gid = idx[pos]
texts.append(ax.text(log2fc[gid], neglog10p[gid], data.var_names[gid], fontsize=5))
from adjustText import adjust_text
adjust_text(texts, arrowprops=dict(arrowstyle='-', color='k', lw=0.5))
return fig if return_fig else None
def rank_plot(
data: Union[MultimodalData, UnimodalData, anndata.AnnData],
panel_size: Optional[Tuple[float, float]] = (6, 4),
return_fig: Optional[bool] = False,
dpi: Optional[float] = 300.0,
**kwargs,
) -> Union[plt.Figure, None]:
"""Generate a barcode rank plot, which shows the total UMIs against barcode rank (in descending order with respect to total UMIs)
Parameters
----------
data : `AnnData` or `UnimodalData` or `MultimodalData` object
The main data object.
panel_size: `tuple`, optional (default: `(6, 4)`)
The plot size (width, height) in inches.
return_fig: ``bool``, optional, default: ``False``
Return a ``Figure`` object if ``True``; return ``None`` otherwise.
dpi: ``float``, optional, default: ``300.0``
The resolution in dots per inch.
Returns
-------
`Figure` object
A ``matplotlib.figure.Figure`` object containing the dot plot if ``return_fig == True``
Examples
--------
>>> fig = pg.rank_plot(data, show = False, dpi = 500)
"""
fig, ax = _get_subplot_layouts(panel_size=panel_size, dpi=dpi) # default nrows = 1 & ncols = 1
numis = data.X.sum(axis = 1).A1
ords = | np.argsort(numis) | numpy.argsort |
#! /usr/bin/env python3
import json
import numpy as np
import matplotlib.pyplot as plt
from korali.plot.helpers import hlsColors, drawMulticoloredLine
import sys, os
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
plotSamples = True
#Plot scatter plot in upper triangle of figure
def plot_upper_triangle(ax, theta, f=None):
dim = theta.shape[1]
for i in range(dim):
for j in range(i + 1, dim):
if f:
ax[i, j].scatter(
theta[:, i], theta[:, j], marker='o', s=3, alpha=0.5, c=f)
else:
ax[i, j].plot(theta[:, i], theta[:, j], '.', markersize=3)
ax[i, j].grid(b=True, which='both')
ax[i, j].set_xlabel("F"+str(i))
ax[i, j].set_ylabel("F"+str(j))
#Plot scatter plot in lower triangle of figure
def plot_lower_triangle(ax, theta, f=None):
dim = theta.shape[1]
for i in range(dim):
for j in range(0, i):
if f:
ax[i, j].scatter(
theta[:, i], theta[:, j], marker='o', s=3, alpha=0.5, c=f)
else:
ax[i, j].plot(theta[:, i], theta[:, j], '.', markersize=3)
ax[i, j].grid(b=True, which='both')
ax[i, j].set_xlabel("F"+str(i))
ax[i, j].set_ylabel("F"+str(j))
def plotGen(genList, idx):
numgens = len(genList)
lastGen = 0
for i in genList:
if genList[i]['Current Generation'] > lastGen:
lastGen = genList[i]['Current Generation']
numObjectives = genList[lastGen]['Problem']['Num Objectives']
if plotSamples and numObjectives > 1:
sampleVals = np.array(genList[lastGen]['Solver']['Sample Value Collection'])
isFinite = [~np.isnan(s - s).any() for s in sampleVals] # Filter trick
sampleVals = sampleVals[isFinite]
numentries = len(sampleVals)
fig, ax = plt.subplots(numObjectives, numObjectives, figsize=(8, 8))
samplesTmp = | np.reshape(sampleVals, (numentries, numObjectives)) | numpy.reshape |
import pytest
from brainlit.algorithms.generate_fragments.adaptive_thresh import (
get_seed,
get_img_T1,
thres_from_gmm,
fast_marching_seg,
level_set_seg,
connected_threshold,
confidence_connected_threshold,
neighborhood_connected_threshold,
otsu,
gmm_seg,
)
import SimpleITK as sitk
from sklearn.mixture import GaussianMixture
import numpy as np
import matplotlib.pyplot as plt
##################
### validation ###
##################
def test_get_seed():
# define voxel
voxel = (10.131, 30.6001, 100)
numpy_seed, sitk_seed = get_seed(voxel)
assert numpy_seed == (10, 30, 100)
assert sitk_seed == (100, 30, 10)
def test_get_img_T1():
img = np.array([[[100, 250], [800, 300]], [[1200, 2000], [3000, 2500]]])
img_T1, img_T1_255 = get_img_T1(img)
assert type(img_T1) == sitk.Image
assert type(img_T1_255) == sitk.Image
assert img_T1_255.GetPixelIDTypeAsString() == "8-bit unsigned integer"
def test_thres_from_gmm():
# define two groups of Gaussian distribution points with distinct mean values
Good1 = False
Good2 = False
# to ensure the random number does not fall below 0 (the minimum value of an 8-bit image)
while Good1 == False:
G1 = np.round(np.random.normal(loc=40, scale=10, size=(499, 1)))
if min(G1) > 0:
Good1 = True
# to ensure the random number does not exceed 255 (the maximum value of an 8-bit image)
while Good2 == False:
G2 = np.round(np.random.normal(loc=220, scale=10, size=(499, 1)))
if max(G2) < 255:
Good2 = True
# the minimum value of the high-mean Gaussian distribution determines the threshold
thre_predicted = np.nanmin(G2)
# construct a 3D image with the two groups of points
img = np.append(np.concatenate((G1, G2)), np.array([[0.0], [255.0]])).reshape(
(10, 10, 10)
)
# calculate the threshold with `thres_from_gmm`
thre = thres_from_gmm(img)
assert thre == thre_predicted
def test_fast_marching_seg():
# create an image comprised of repeated 1D Gaussian distribution with mean value at 50th pixel and standard deviation of 2 pixels
Gx = np.array([])
for x in range(0, 101):
Gx = np.insert(Gx, x, np.exp(-((x - 50) ** 2) / (2 * (2**2))))
img = np.repeat([Gx], repeats=30, axis=0)
# place a seed in the region of mean value
seed = (50, 15)
# input default settings of the fast_marching_seg function
stopping_value = 150
sigma = 0.5
# convert image format to comply with SimpleITK
_, img_T1_255 = get_img_T1(img)
# explicitly applying SimpleITK filters accordingly as in the fast_marching_seg function
feature_img = sitk.GradientMagnitudeRecursiveGaussian(img_T1_255, sigma=sigma)
speed_img = sitk.BoundedReciprocal(feature_img)
fm_filter = sitk.FastMarchingBaseImageFilter()
fm_filter.SetTrialPoints([seed])
fm_filter.SetStoppingValue(stopping_value)
fm_img = fm_filter.Execute(speed_img)
fm_img = sitk.Cast(sitk.RescaleIntensity(fm_img), sitk.sitkUInt8)
labels_predicted = sitk.GetArrayFromImage(fm_img)
# the prediceted labels is obtained by explicitly running the fast_marching function
labels_predicted = (~labels_predicted.astype(bool)).astype(int)
# acquire labels by employing the fast_marching_seg function
labels = fast_marching_seg(img, seed, sigma=sigma)
np.testing.assert_array_equal(labels, labels_predicted)
def test_level_set_seg():
# create an image comprised of repeated 1D Gaussian distribution with mean value at 50th pixel and standard deviation of 2 pixels
Gx = np.array([])
for x in range(0, 101):
Gx = np.insert(Gx, x, np.exp(-((x - 50) ** 2) / (2 * (2**2))))
img = np.repeat([Gx], repeats=30, axis=0)
# place a seed in the region of mean value
seed = (50, 15)
# input default settings of the fast_marching_seg function
lower_threshold = None
upper_threshold = None
factor = 2
max_rms_error = 0.02
num_iter = 1000
curvature_scaling = 0.5
propagation_scaling = 1
# convert image format to comply with SimpleITK
_, img_T1_255 = get_img_T1(img)
# explicitly applying SimpleITK filters accordingly and run default threshold algorithms as in the level_seg_set function
seg = sitk.Image(img_T1_255.GetSize(), sitk.sitkUInt8)
seg.CopyInformation(img_T1_255)
seg[seed] = 1
seg = sitk.BinaryDilate(seg, [1] * seg.GetDimension())
stats = sitk.LabelStatisticsImageFilter()
stats.Execute(img_T1_255, seg)
if lower_threshold == None:
lower_threshold = stats.GetMean(1) - factor * stats.GetSigma(1)
if upper_threshold == None:
upper_threshold = stats.GetMean(1) + factor * stats.GetSigma(1)
init_ls = sitk.SignedMaurerDistanceMap(
seg, insideIsPositive=True, useImageSpacing=True
)
lsFilter = sitk.ThresholdSegmentationLevelSetImageFilter()
lsFilter.SetLowerThreshold(lower_threshold)
lsFilter.SetUpperThreshold(upper_threshold)
lsFilter.SetMaximumRMSError(max_rms_error)
lsFilter.SetNumberOfIterations(num_iter)
lsFilter.SetCurvatureScaling(curvature_scaling)
lsFilter.SetPropagationScaling(propagation_scaling)
lsFilter.ReverseExpansionDirectionOn()
ls = lsFilter.Execute(init_ls, sitk.Cast(img_T1_255, sitk.sitkFloat32))
# the prediceted labels is obtained by explicitly running the level_set_seg function
labels_predicted = sitk.GetArrayFromImage(ls > 0)
# acquire labels by employing level_set_seg function
labels = level_set_seg(img, seed, lower_threshold=None, upper_threshold=None)
np.testing.assert_array_equal(labels, labels_predicted)
def test_connected_threshold():
# create an image with 4 layers of gray scales
G1 = np.full((4, 4), 255)
G2 = np.full((4, 4), 200)
G3 = np.full((4, 4), 100)
G4 = np.full((4, 4), 0)
img = np.concatenate((G1, G2, G3, G4)).reshape(4, 4, 4)
# seed at the first layer with the highest gray level and give a lower_threshold
labels = connected_threshold(img, [(0, 0, 0)], lower_threshold=150)
# because the gray levels are arranged in a sequantial order, gray level above the threshold should be all labeled 1, otherwise 0
labels_predicted = np.concatenate(
((G1 / G1).astype(int), (G2 / G2).astype(int), G3 - G3, G4 - G4)
).reshape(4, 4, 4)
np.testing.assert_array_equal(labels, labels_predicted)
# seed at the first layer without giving a lower_threshold
labels = connected_threshold(img, [(0, 0, 0)])
# since no threshold is given, the default is to use thres_from_gmm to determine the threshold (200 in this case)
labels_predicted = np.concatenate(
((G1 / G1).astype(int), (G2 / G2).astype(int), G3 - G3, G4 - G4)
).reshape(4, 4, 4)
np.testing.assert_array_equal(labels, labels_predicted)
def test_confidence_connected_threshold():
# create a data set featured with Gaussian distribution
Good = False
# to ensure the random number does not fall outside of 0 to 255 range (dynamic range of an 8-bit image)
while Good == False:
G1 = np.round(np.random.normal(loc=125, scale=25, size=(62500, 1)))
if min(G1) > 0 and max(G1) < 255:
Good = True
# the data is distributed in the image by the order of each pixel's intensity
img = np.sort(G1).reshape(250, 250).astype(int)
# if we set multiplier to be 2.5, we are expected to connect around 99% of the pixels
labels = confidence_connected_threshold(
img, [(124, 127)], multiplier=2.5, num_iter=180
)
assert sum(sum(labels.astype(float))) / 62500 > 0.98
def test_neighborhood_connected_threshold():
# define an image with 2D Gaussian distribution
Gx = np.array([])
for x in range(0, 7):
Gx = np.insert(Gx, x, np.exp(-((x - 3) ** 2) / (2 * (3**2))))
Gxy = np.zeros((7, 7))
for x in range(0, 7):
for y in range(0, 7):
Gxy[x, y] = (Gx[x]) * (Gx[y])
img = 255 * (Gxy / Gxy.max())
# pick the central pixel as the seed and threshold at 200
lower_threshold = 200
seed = (3, 3)
labels = neighborhood_connected_threshold(
img, [seed], lower_threshold=lower_threshold
)
# all the neighbor pixels within radius=(1,1,1) should fit in the threshold
labels_predicted = np.zeros((7, 7))
labels_predicted[3, 3] = 1
np.testing.assert_array_equal(labels, labels_predicted)
def test_otsu():
G1 = np.append(
np.round(np.random.normal(loc=40, scale=10, size=(499, 1))), np.array([0])
)
G2 = np.append(
np.round(np.random.normal(loc=220, scale=10, size=(499, 1))), np.array([255])
)
img = np.concatenate((G1, G2)).reshape((10, 10, 10))
# seed inside
labels = otsu(img, (9, 1, 6))
labels_predicted = np.concatenate(
((G1 - G1).astype(int), (G2 / G2).astype(int))
).reshape((10, 10, 10))
np.testing.assert_array_equal(labels, labels_predicted)
# seed outside
labels = otsu(img, (1, 1, 3))
labels_predicted = np.concatenate(
((G1 + (255 - G1)).astype(int), (G2 - G2).astype(int))
).reshape((10, 10, 10))
np.testing.assert_array_equal(labels, labels_predicted)
def test_gmm_seg():
# define two groups of Gaussian distribution points with distinct mean values
G1 = np.append(
np.round(np.random.normal(loc=40, scale=10, size=(499, 1))), np.array([0])
)
G2 = np.append(
np.round(np.random.normal(loc=220, scale=10, size=(499, 1))), np.array([255])
)
# construct a 3D image with the two groups of points
img = np.concatenate((G1, G2)).reshape((10, 10, 10))
# 1s should be labeled to the positions where G2 population are located
labels_predicted = np.concatenate(
((G1 - G1).astype(int), (G2 / G2).astype(int))
).reshape((10, 10, 10))
# the seed is located at a randomly selected point within G2 distribution
labels = gmm_seg(img, (9, 9, 6))
| np.testing.assert_array_equal(labels, labels_predicted) | numpy.testing.assert_array_equal |
# To add a new cell, type '# %%'
# To add a new markdown cell, type '# %% [markdown]'
# %% [markdown]
# # Setup
#
# ## Import TensorFlow and NumPy
# %%
# Import libraries
import os
import numpy as np
import tensorflow as tf
import tensorflow.keras as keras
from tensorflow.keras import backend as K
from tensorflow.keras.models import load_model
from tensorflow.keras.datasets import cifar10
import argparse
parser = argparse.ArgumentParser(description='Inference characterization.')
parser.add_argument('i', type=int, help='i value to process')
args = parser.parse_args()
# %% [markdown]
# ## Configure DNN settings
#
# Here, we specify the ResNet architecture parameters:
# %%
# Number of classes to infer
num_classes = 10
# Subtracting pixel mean improves accuracy
subtract_pixel_mean = True
# Depth parameter
n = 3
# Model version
# Orig paper: version = 1 (ResNet v1), Improved ResNet: version = 2 (ResNet v2)
version = 1
# Computed depth from supplied model parameter n
if version == 1:
depth = n * 6 + 2
elif version == 2:
depth = n * 9 + 2
# %% [markdown]
# ## Load dataset and preprocess
#
# We are working with the [CIFAR-10 dataset](https://www.cs.toronto.edu/~kriz/cifar.html) here.
# %%
# Load the CIFAR10 data
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
# Input image dimensions
input_shape = x_train.shape[1:]
# Normalize data
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
# If subtract pixel mean is enabled
if subtract_pixel_mean:
x_train_mean = | np.mean(x_train, axis=0) | numpy.mean |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import json
import math
import numpy
class Wavefront():
def __init__(self, path, triangulateQuads = True):
# These are the arrays we're going to produce, and which might
# make sense to manipulate from the outside:
self.vertexCoords = None # XYZ coordinated for each vertex
self.vertexNormals = None # Normal (in XYZ form) for each vertex
self.faces = None # Faces, specified by listing indexes for participating vertices
# These are internal work arrays
self._rawVertices = []
self._rawTexCo = []
self._rawVertexTexCo = [];
self._rawFaces = []
self._vertexBelongsToFaces = None
self._faceVertCache = None
self.triangulateQuads = triangulateQuads
if not os.path.exists(path):
raise IOError(path + " does not exist")
self.content = []
with open(path,'r') as file:
self.content = file.readlines()
# self._mode can be:
# ONLYTRIS: The incoming mesh only contains tris (so no need to do anything)
# TRIANGULATE: The incoming mesh contains quads (and may contain tris). Triangulate to get only tris.
# ONLYQUADS: The incoming mesh contains only quads. Keep these rather than triangulating
self._mode = None
# Check if mesh contains quads and/or tris
self._scanForMode()
# Make a sweep for vertices as faces need that information
self._extractVertices()
# Make a sweep for texture coordinates, as faces need that too
self._extractTextureCoordinates()
# Make a sweep for faces
self._extractFaces()
# TODO: Find texture coordinates for vertices
# create numpy arrays to contain vertices, faces and normals
self._createVerticesNumpyArray()
self._createFacesNumpyArray()
# These two operations need to be redone if vertex coordinates
# are changed
self.recalculateFaceNormals()
self.recalculateVertexNormals()
def _scanForMode(self):
containsTris = False
containsQuads = False
for line in self.content:
strippedLine = line.strip()
if not strippedLine is None and not strippedLine == "" and not strippedLine[0] == "#":
parts = strippedLine.split(' ')
if len(parts) > 4:
containsQuads = True
if len(parts) == 4:
containsTris = True
if len(parts) > 5:
raise ValueError("Found a face with more than four vertices. N-gons are not supported.")
# TODO: Check for n-gons?
if containsQuads:
if self.triangulateQuads:
self._mode = "TRIANGULATE"
else:
if containsTris:
raise ValueError("Since the mesh contains both tris and quads, requesting the mesh to not be triangulated is illegal")
else:
self._mode = "ONLYQUADS"
else:
if containsTris:
self._mode = "ONLYTRIS"
else:
raise ValueError("The mesh didn't contain tris nor quads!?")
if self._mode == "ONLYQUADS":
raise ValueError("The ONLYQUADS mode is not implemented yet")
print("Tris " + str(containsTris))
print("Quads " + str(containsQuads))
print(self._mode)
def _extractVertices(self):
for line in self.content:
strippedLine = line.strip()
if not strippedLine is None and not strippedLine == "" and not strippedLine[0] == "#":
parts = strippedLine.split(' ')
if len(parts) > 1:
command = parts[0]
if command == "v":
x = float(parts[1])
y = float(parts[2])
z = float(parts[3])
vertex = [x, y, z]
self._rawVertices.append(vertex)
self._rawVertexTexCo.append([0,0])
def _extractTextureCoordinates(self):
self.hasTexCo = False
for line in self.content:
strippedLine = line.strip()
if not strippedLine is None and not strippedLine == "" and not strippedLine[0] == "#":
parts = strippedLine.split(' ')
if len(parts) > 1:
command = parts[0]
if command == "vt":
x = float(parts[1])
y = float(parts[2])
texco = [x, y]
self._rawTexCo.append(texco)
def _distanceBetweenVerticesByIdx(self, idx1, idx2):
vert1 = numpy.array(self._rawVertices[idx1])
vert2 = numpy.array(self._rawVertices[idx2])
difference = vert2 - vert1
x = difference[0]
y = difference[1]
z = difference[2]
distance = math.sqrt( x*x + y*y + z*z )
return distance
def _extractFaces(self):
# Note that wavefront lists starts at 1, not 0
for line in self.content:
strippedLine = line.strip()
if not strippedLine is None and not strippedLine == "" and not strippedLine[0] == "#":
parts = strippedLine.split(' ')
if len(parts) > 1:
command = parts[0]
if command == "f":
# Face info is vertIdx / texCoIdx / faceNormalIdx OR vertIdx / texCoIdx OR vertIdx
vInfo1 = parts[1].split('/')
vInfo2 = parts[2].split('/')
vInfo3 = parts[3].split('/')
# Find indexes of vertices making up the face. Note "-1" since wavefront indexes start
# at 1 rather than 0
vidx1 = int(vInfo1[0]) - 1
vidx2 = int(vInfo2[0]) - 1
vidx3 = int(vInfo3[0]) - 1
if len(parts) == 4:
if self._mode == "ONLYQUADS":
raise ValueError("Found tri although mode was ONLYQUADS")
face = [vidx1, vidx2, vidx3]
self._rawFaces.append(face)
else:
vInfo4 = parts[4].split('/')
vidx4 = int(vInfo4[0]) - 1
if self._mode == "ONLYTRIS":
raise ValueError("Found quad although mode was ONLYTRIS")
if self._mode == "ONLYQUADS":
raise ValueError("ONLYQUADS mode not implemented yet")
# Perform triangulation by splitting quad into two tris, using the shortest diagonal
distance13 = self._distanceBetweenVerticesByIdx(vidx1, vidx3)
distance24 = self._distanceBetweenVerticesByIdx(vidx2, vidx4)
if distance13 > distance24:
face = [vidx1, vidx2, vidx4]
self._rawFaces.append(face)
face = [vidx3, vidx4, vidx2]
self._rawFaces.append(face)
else:
face = [vidx1, vidx3, vidx4]
self._rawFaces.append(face)
face = [vidx2, vidx3, vidx1]
self._rawFaces.append(face)
i = 1
while i < len(parts):
f = parts[i].split('/')
if len(f) > 1:
vidx = int(f[0]) - 1 # Vertex index
ti = f[1] # May be empty if no UV unwrap
if ti != "":
tidx = int(ti) - 1 # Texture coordinate index
texco = self._rawTexCo[tidx] # Actual texture coordinats, x/y
self._rawVertexTexCo[vidx] = texco
self.hasTexCo = True
i = i + 1
def _createFacesNumpyArray(self, assumeQuads = False):
numberOfFaces = len(self._rawFaces)
vertsPerFace = 3
if assumeQuads:
vertsPerFace = 4
# Create a two-dimensional int array with shape (numFace/vertsPerFace) and
# fill it values from the wavefront obj. This will contain vert indices.
self.faces = numpy.array( self._rawFaces, dtype=int ) # Values will be copied from self._rawFaces
# Create a two-dimensional float array with shape (numFace/ 3 ) and
# fill it with zeros. This will contain faces normals, but needs to
# be recalculated.
self.faceNormals = numpy.zeros( (numberOfFaces, 3), dtype=float )
def _createVerticesNumpyArray(self):
numberOfVertices = len(self._rawVertices)
if numberOfVertices != len(self._rawVertexTexCo):
raise ValueError("Not same number of elements in texco array")
# Convert raw coords from wavefront into a 2d numpy array
self.vertexCoords = numpy.array( self._rawVertices, dtype=float )
# Create a two-dimensional float array with shape (numVerts/3) and
# fill it with zeros. This will contain vertex normals.
self.vertexNormals = numpy.zeros( (numberOfVertices, 3), dtype=float )
# Create a two-dimensional float array with shape (numVerts/2) and
# fill it with texture coordinates.
self.vertexTexCo = numpy.array( self._rawVertexTexCo, dtype=float )
def recalculateVertexNormals(self, assumeQuads = False):
# Build a cache where we, per vertex, list which faces are relevant
# for it. We need this in order to calculate the vertex normal later,
# as an average of the face normals surrounding it
if self._vertexBelongsToFaces is None:
self._vertexBelongsToFaces = []
numberOfFaces = len(self.faces)
numberOfVertices = len(self.vertexCoords)
vertsPerFace = 3
if assumeQuads:
vertsPerFace = 4
currentVert = 0
while currentVert < numberOfVertices:
self._vertexBelongsToFaces.append([])
currentVert = currentVert + 1
currentFace = 0
while currentFace < numberOfFaces:
fv = self.faces[currentFace]
currentVert = 0
while currentVert < vertsPerFace:
vertexIndex = fv[currentVert]
self._vertexBelongsToFaces[vertexIndex].append(currentFace)
currentVert = currentVert + 1
currentFace = currentFace + 1
# Calculate vertex normals as an average of the surrounding face
# normals.
currentVert = 0
zeroNormal = numpy.array([0.0, 0.0, 0.0], dtype=float)
while currentVert < numberOfVertices:
faces = self._vertexBelongsToFaces[currentVert]
numberOfFaces = len(faces)
currentNormal = numpy.array([0,0,0], dtype=float)
currentFace = 0
firstNormal = None
while currentFace < numberOfFaces:
fidx = faces[currentFace]
fnormal = self.faceNormals[fidx]
if firstNormal is None:
firstNormal = fnormal
currentNormal = currentNormal + fnormal
currentFace = currentFace + 1
if numberOfFaces < 1:
raise ValueError("Found a vertex (" + str(currentVert) + ") which did not belong to any face")
averageNormal = currentNormal / numberOfFaces
if | numpy.array_equal(averageNormal, zeroNormal) | numpy.array_equal |
# -*- coding:utf-8 -*-
#
# Author : 寒江雪
# E-mail :
# Date : 19/11/09 21:03:30
# Desc : 使用DDPG的方法玩flappy bird
#
"""
Dependencies:
tensorflow r1.14
pygame 1.9.4
"""
from __future__ import print_function
import tensorflow as tf
import cv2
import sys
sys.path.append("game/")
import wrapped_flappy_bird as game
import random
import numpy as np
from collections import deque
import os
class Config(object):
GAME = 'bird'
ACTIONS = 2
GAMMA = 0.99
OBSERVE = 100000.0
EXPLORE = 2000000.0
FINAL_EPSILON = 0.0001
INITIAL_EPSILON = 0.06
REPLAY_MEMORY = 50000
BATCH = 32
FRAME_PER_ACTION = 1
SAVE_MODEL_EVERY = 10000
S = tf.placeholder("float", [None, 80, 80, 4])
class PolicyGradient(object):
def __init__(self, scope='estimator', log_dir=None, config=Config):
self.scope = scope
self.summary_writer = None
self.config = config
with tf.variable_scope(scope):
self.a = self.build_graph()
def weight_variable(self, shape):
initial = tf.truncated_normal(shape, stddev = 0.01)
return tf.Variable(initial)
def bias_variable(self, shape):
initial = tf.constant(0.01, shape = shape)
return tf.Variable(initial)
def conv2d(slef, x, W, stride):
return tf.nn.conv2d(x, W, strides = [1, stride, stride, 1], padding = "SAME")
def max_pool_2x2(self, x):
return tf.nn.max_pool(x, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")
def build_graph(self):
with tf.variable_scope("network"):
# network weights
W_conv1 = self.weight_variable([8, 8, 4, 32])
b_conv1 = self.bias_variable([32])
W_conv2 = self.weight_variable([4, 4, 32, 64])
b_conv2 = self.bias_variable([64])
W_conv3 = self.weight_variable([3, 3, 64, 64])
b_conv3 = self.bias_variable([64])
W_fc1 = self.weight_variable([1600, 512])
b_fc1 = self.bias_variable([512])
W_fc2 = self.weight_variable([512, self.config.ACTIONS])
b_fc2 = self.bias_variable([self.config.ACTIONS])
h_conv1 = tf.nn.relu(self.conv2d(S, W_conv1, 4) + b_conv1)
h_pool1 = self.max_pool_2x2(h_conv1)
h_conv2 = tf.nn.relu(self.conv2d(h_pool1, W_conv2, 2) + b_conv2)
#h_pool2 = max_pool_2x2(h_conv2)
h_conv3 = tf.nn.relu(self.conv2d(h_conv2, W_conv3, 1) + b_conv3)
#h_pool3 = max_pool_2x2(h_conv3)
#h_pool3_flat = tf.reshape(h_pool3, [-1, 256])
h_conv3_flat = tf.reshape(h_conv3, [-1, 1600])
h_fc1 = tf.nn.relu(tf.matmul(h_conv3_flat, W_fc1) + b_fc1)
# 输出动作的最大值
self.readout = tf.matmul(h_fc1, W_fc2) + b_fc2
#利用softmax函数得到每个动作的概率
self.all_act_prob = tf.nn.softmax(self.readout, name='act_prob')
return self.all_act_prob
def predict(self, sess, s_t):
all_act_prob = sess.run(self.all_act_prob, feed_dict={S: s_t})
return np.argmax(all_act_prob[0].ravel())
class QValueEvaluation(object):
def __init__(self, scope='estimator', actor=None, config=Config):
self.scope = scope
self.summary_writer = None
self.config = config
with tf.variable_scope(scope):
self.a = self.build_graph(actor)
def weight_variable(self, shape):
initial = tf.truncated_normal(shape, stddev = 0.01)
return tf.Variable(initial)
def bias_variable(self, shape):
initial = tf.constant(0.01, shape = shape)
return tf.Variable(initial)
def conv2d(slef, x, W, stride):
return tf.nn.conv2d(x, W, strides = [1, stride, stride, 1], padding = "SAME")
def max_pool_2x2(self, x):
return tf.nn.max_pool(x, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")
def build_graph(self, actor):
with tf.variable_scope("network"):
# network weights
W_conv1 = self.weight_variable([8, 8, 4, 32])
b_conv1 = self.bias_variable([32])
W_conv2 = self.weight_variable([4, 4, 32, 64])
b_conv2 = self.bias_variable([64])
W_conv3 = self.weight_variable([3, 3, 64, 64])
b_conv3 = self.bias_variable([64])
W_fc1 = self.weight_variable([1600, 512])
b_fc1 = self.bias_variable([512])
W_fc2 = self.weight_variable([512, self.config.ACTIONS])
b_fc2 = self.bias_variable([self.config.ACTIONS])
W_fc3 = self.weight_variable([2*self.config.ACTIONS, 1])
b_fc3 = self.bias_variable([1])
h_conv1 = tf.nn.relu(self.conv2d(S, W_conv1, 4) + b_conv1)
h_pool1 = self.max_pool_2x2(h_conv1)
h_conv2 = tf.nn.relu(self.conv2d(h_pool1, W_conv2, 2) + b_conv2)
#h_pool2 = max_pool_2x2(h_conv2)
h_conv3 = tf.nn.relu(self.conv2d(h_conv2, W_conv3, 1) + b_conv3)
#h_pool3 = max_pool_2x2(h_conv3)
#h_pool3_flat = tf.reshape(h_pool3, [-1, 256])
h_conv3_flat = tf.reshape(h_conv3, [-1, 1600])
h_fc1 = tf.nn.relu(tf.matmul(h_conv3_flat, W_fc1) + b_fc1)
# readout layer
self.readout = tf.matmul(h_fc1, W_fc2) + b_fc2
self.concat_1 = tf.concat([self.readout, actor], 1)
self.q_values = tf.matmul(self.concat_1, W_fc3) + b_fc3
self.y = tf.placeholder("float", [None])
self.cost = tf.reduce_mean(tf.square(self.y - self.q_values))
self.train_step = tf.train.AdamOptimizer(1e-6).minimize(self.cost)
def predict(self, sess, s_t):
q_values = sess.run(self.readout, feed_dict={self.s: s_t})
return q_values
def train(self, sess, s_j_batch, y_batch):
_, summaries, global_step = sess.run(
[self.train_step, self.summaries, tf.train.get_global_step()],
feed_dict={
self.y: y_batch,
S: s_j_batch}
)
def n_step_copy_model_parameters(q_value, target_q):
def get_params(estimator):
params = [t for t in tf.trainable_variables() if t.name.startswith(estimator.scope)]
params = sorted(params, key=lambda t: t.name)
return params
params = get_params(q_value)
target_params = get_params(target_q)
assign_ops = []
for t, target_t in zip(params, target_params):
assign_op = tf.assign(ref=target_t, value=t)
assign_ops.append(assign_op)
"""
for t, target_t in zip(params, target_params):
assign_op = tf.assign(target_t, (1-0.9)*t + 0.9*target_t)
assign_ops.append(assign_op)
"""
return assign_ops
def preprocess_state(x_t):
x_t = cv2.cvtColor(cv2.resize(x_t, (80, 80)), cv2.COLOR_BGR2GRAY)
ret, x_t = cv2.threshold(x_t, 1, 255, cv2.THRESH_BINARY)
return x_t
def train_ddpg(sess, actor_eval_net, actor_target_net, actor_assign_ops,
critic_eval_net, critic_target_net, critic_assign_ops):
# 开始游戏
game_state = game.GameState()
# 存储样本
D = deque()
do_nothing = np.zeros(Config.ACTIONS)
do_nothing[0] = 1
x_t, r_0, terminal = game_state.frame_step(do_nothing)
x_t = preprocess_state(x_t)
s_t = | np.stack((x_t, x_t, x_t, x_t), axis=2) | numpy.stack |
import matplotlib.pyplot as plt
import numpy as np
import matplotlibex as plx
import matplotlibex.mlplot as plx
import dmp.equations as deq
class LocalFunc(object):
def __init__(self):
pass
def __call__(self, x):
raise NotImplementedError()
def plot(self, t, x):
plt.plot(range(len(t)), self(x))
class RBFLocalFunc(LocalFunc):
def __init__(self, center, sigmasqr):
super(RBFLocalFunc, self).__init__()
self.center = center
self.sigmasqr = sigmasqr
def __call__(self, x):
return deq.RBF(self.center, self.sigmasqr, x)
class MisesBFLocalFunc(LocalFunc):
def __init__(self, center, sigmasqr):
super(MisesBFLocalFunc, self).__init__()
self.center = center
self.sigmasqr = sigmasqr
def __call__(self, x):
return deq.MisesBF(self.center, self.sigmasqr, x)
class LWR_1D(object):
def __init__(self, x, y, npsi=20, regressor_func=None, local_funcs=None):
self.x = x.copy()
self.y = y.copy()
if regressor_func is None:
regressor_func = lambda x: np.ones_like(x)
self.regressor_func = regressor_func
if local_funcs is None:
xmin = np.min(self.x)
xmax = np.max(self.x)
psi_cs = np.linspace(xmin, xmax, npsi) # basis functions centres
psi_ls = np.zeros([npsi]) + 0.5 * ((xmax - xmin) / npsi)**2
local_funcs = [RBFLocalFunc(center=psi_cs[i], sigmasqr=psi_ls[i]) for i in range(npsi)]
self.local_funcs = local_funcs
self.npsi = len(self.local_funcs)
ksi = self.regressor_func(x)
self.ws = np.zeros([self.npsi])
for i in range(self.npsi):
psi_i = self.get_psi_value(i, x)
self.ws[i] = np.sum(ksi * psi_i * y) / np.sum(ksi * psi_i * ksi)
def get_psi_value(self, i, x):
return self.local_funcs[i](x)
def predict(self, xstar):
if not isinstance(xstar, np.ndarray):
xstar = np.array([xstar])
ksi = self.regressor_func(xstar) #[N]
psi = [self.get_psi_value(i, xstar) for i in range(self.npsi)] # [npsi][N]
psi = np.vstack(psi).T # [N, npsi]
res = np.sum(psi * ksi[:, np.newaxis] * self.ws[np.newaxis, :], axis=1) / np.sum(psi, axis=1)
return res
def plot_BFs(self, xstar):
for i in range(self.npsi):
plt.plot(xstar, self.get_psi_value(i, xstar))
class LWR(object):
def __init__(self, x, y, npsi=20, regressor_func=None, local_funcs=None):
self.D = y.shape[1]
self.lwrs = []
for i in range(self.D):
lwr = LWR_1D(x,
y[:, i],
npsi,
None if regressor_func is None else regressor_func[i],
local_funcs)
self.lwrs.append(lwr)
def predict(self, xstar):
return np.array([lwr.predict(xstar) for lwr in self.lwrs]).T
def plot_BFs(self, xstar):
self.lwrs[0].plot_BFs(xstar)
def test_LWR_1D():
T = np.linspace(0.0, 11.0, 100)
Y = | np.sin(T) | numpy.sin |
import numpy as np
import cv2
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import glob
def find_lane_pixels(binary_warped):
"""
find lane in a binary_warped image
input: binary_warped image
output: left/right lane pixel poistion and a drawed search image
"""
# Take a histogram of the bottom half of the image
histogram = np.sum(binary_warped[binary_warped.shape[0]//2:,:], axis=0)
# plt.plot(histogram)
# plt.show()
# Create an output image to draw on and visualize the result
out_img = np.dstack((binary_warped, binary_warped, binary_warped))*255
# Find the peak of the left and right havleve of the histogram
# These will be the starting point for the left and right lines
midpoint = np.int(histogram.shape[0]//2) # 1280/2=640
leftx_base = np.argmax(histogram[:midpoint])
rightx_base = np.argmax(histogram[midpoint:]) + midpoint
# HYPERPARAMETERS
# Choose the number of sliding windows
nWindows = 9
# Set the width of the windows +/- margin
margin = 100
# Set minimu number of pixels found to recenter window
min_pix = 50
# Set height of windows - based on nWindows above adn image shape
window_height = np.int(binary_warped.shape[0]//nWindows)
# Identify the x and y positions of all nonzero(i.e. activated) pixels in the image
nonzero = binary_warped.nonzero()
nonzeroy = np.array(nonzero[0]) # y is row, x is col
nonzerox = np.array(nonzero[1])
# Current postions to be updated later for each window in n_window
leftx_current = leftx_base
rightx_current = rightx_base
# Create empty lists to receive left and right lane pixel indices
left_lane_inds = []
right_lane_inds = []
for window in range(nWindows):
# Identify window boundaries in x and y (and right and left)
win_y_low = binary_warped.shape[0] - (window+1)*window_height
win_y_high = binary_warped.shape[0] - window*window_height
win_xleft_low = leftx_current - margin
win_xleft_high = leftx_current + margin
win_xright_low = rightx_current - margin
win_xright_high = rightx_current + margin
# Draw the windows on the visulization image
cv2.rectangle(out_img, (win_xleft_low, win_y_low),
(win_xleft_high, win_y_high), (0,255,0),2)
cv2.rectangle(out_img, (win_xright_low, win_y_low),
(win_xright_high, win_y_high), (0,255,0),2)
# plt.imshow(out_img)
# plt.show()
good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
(nonzerox >= win_xleft_low) & (nonzerox < win_xleft_high)).nonzero()[0] # nonzero() return a tuple, get the list for tuple
good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
(nonzerox >= win_xright_low) & (nonzerox < win_xright_high)).nonzero()[0] # nonzero() return a tuple, get the list for tuple
# Append these indices to hte lists
left_lane_inds.append(good_left_inds)
right_lane_inds.append(good_right_inds)
# # update the window center for next round window scan
if len(good_left_inds) > min_pix:
leftx_current = int(np.mean(nonzerox[good_left_inds]))
if len(good_right_inds) > min_pix:
rightx_current = int(np.mean(nonzerox[good_right_inds]))
# Concatenate the arrays of indices (previously was a list of list)
try:
left_lane_inds = np.concatenate(left_lane_inds)
right_lane_inds = np.concatenate(right_lane_inds)
except ValueError:
# Avoids an error if the above is not implemented fully
pass
# Extract left and right line pixel positions
leftx = nonzerox[left_lane_inds]
lefty = nonzeroy[left_lane_inds]
rightx = nonzerox[right_lane_inds]
righty = nonzeroy[right_lane_inds]
# print(len(nonzerox))
return (leftx, lefty, rightx, righty, out_img)
def fit_polynomial(leftx, lefty, rightx, righty, out_img):
# Find our lane pixels first
#leftx, lefty, rightx, righty, out_img = find_lane_pixels(binary_warped)
# check if there is search failure
if leftx.size == 0 or lefty.size == 0:
cv2.putText(out_img,"Search failure", (50,60), cv2.FONT_HERSHEY_SIMPLEX,2,(255,0,255),3)
return out_img
# Fit a second order polynomial to each using `np.polyfit`
left_fit = np.polyfit(lefty, leftx, 2)
right_fit = np.polyfit(righty, rightx, 2)
# Generate x and y values for plotting
ploty = | np.linspace(0, out_img.shape[0]-1, out_img.shape[0] ) | numpy.linspace |
import itertools
import pytest
import numpy as np
import tensorflow as tf
from dlutils.dataset.cropping import random_crop
CROP_TEST_PARAMS = list(
itertools.product(
[(5, 10, 11, 2), (20, 10, 3), (5, 10)], # patch_size
[2, 5])) # n_inputs
def pairwise(iterable):
'''s -> (s0,s1), (s1,s2), (s2, s3), ...
Snippet from https://docs.python.org/3.6/library/itertools.html
'''
a, b = itertools.tee(iterable)
next(b, None)
return zip(a, b)
@pytest.mark.parametrize('patch_size, n_inputs', CROP_TEST_PARAMS)
def test_random_crop_on_dict(patch_size, n_inputs):
'''test tf.data compatible random crop function on an input_dict.
'''
tf.random.set_seed(17)
img_shape = tuple(2 * val for val in patch_size)
img = np.arange(np.prod(img_shape)).reshape(img_shape)
cropper = random_crop(patch_size)
input_dict = {key: key * img for key in range(1, n_inputs + 1)}
first_patch = cropper(input_dict)
for _ in range(10):
patch = cropper(input_dict)
# check if patches have the correct shape
for key in input_dict.keys():
vals = patch[key].numpy()
assert vals.ndim == img.ndim
assert np.all(vals.shape == patch_size)
assert len(patch.keys()) == n_inputs
# check if all inputs were cropped in the same location
for first_key, second_key in pairwise(patch):
assert np.all(patch[first_key].numpy() *
second_key == patch[second_key].numpy() * first_key)
# make sure we're not drawing the same patch over and over
for key in patch.keys():
assert not np.all(patch[key].numpy() == first_patch[key].numpy())
@pytest.mark.parametrize('patch_size, n_inputs', CROP_TEST_PARAMS)
def test_random_crop_on_list(patch_size, n_inputs):
'''test tf.data compatible random crop function on a list.
NOTE we currently expect the test to fail as there's no extra handling
of lists/tuples/dicts
'''
tf.random.set_seed(17)
img_shape = tuple(2 * val for val in patch_size)
img = np.arange(np.prod(img_shape)).reshape(img_shape)
cropper = random_crop(patch_size)
input_list = [key * img for key in range(1, n_inputs + 1)]
first_patch = cropper(input_list)
for _ in range(10):
patch = cropper(input_list)
# check if patches have the correct shape
for vals in patch:
vals = vals.numpy()
assert vals.ndim == img.ndim
assert | np.all(vals.shape == patch_size) | numpy.all |
import torch
import numpy as np
from math import sqrt
import imghdr
from .data_interface import DataInterface
from torch import as_tensor, uint8
class BloscInterface(DataInterface):
@staticmethod
def blosc_opts(complevel=9, complib='blosc:lz4hc', shuffle: any = 'bit'):
"""
Code from https://github.com/h5py/h5py/issues/611#issuecomment-497834183 for issue https://github.com/h5py/h5py/issues/611
:param complevel:
:param complib:
:param shuffle:
:return:
"""
shuffle = 2 if shuffle == 'bit' else 1 if shuffle else 0
compressors = ['blosclz', 'lz4', 'lz4hc', 'snappy', 'zlib', 'zstd']
complib = ['blosc:' + c for c in compressors].index(complib)
args = {
'compression': 32001,
'compression_opts': (0, 0, 0, 0, complevel, shuffle, complib)
}
if shuffle:
args['shuffle'] = False
return args
@staticmethod
def load_sample(sample):
from PIL import Image
from skimage import io as skio
import io
path_key = 'path' if 'path' in sample.keys() else 'FilePath'
type_key = 'type' if 'type' in sample.keys() else 'FileType'
try:
file_type = sample[type_key]
except KeyError:
file_type = imghdr.what(sample[path_key])
if file_type in ['tif', 'tiff']:
spl = skio.imread(sample[path_key])
spl = np.moveaxis(np.array(spl), -1, 0)
return spl, spl.shape
elif file_type in ['numpy', 'np']:
spl = np.load(sample[path_key])
return spl, spl.shape
else:
with open(sample[path_key], 'rb') as f:
im = Image.open(io.BytesIO(f.read()))
if len(im.getbands()) < 3:
rgbimg = Image.new("RGB", im.size)
rgbimg.paste(im)
im = rgbimg
im = np.array(im)
im = np.moveaxis(np.array(im), -1, 0)
return im, im.shape
@staticmethod
def stack_batch_data_padded(batch_list):
max_height = max(batch_list, key=lambda x: x['height'])['height']
max_width = max(batch_list, key=lambda x: x['width'])['width']
batch_array = None
batch_dimensions = None
for sample_idx, sample in enumerate(batch_list):
sample_shape = sample['shape']
im, im_shape = BloscInterface.load_sample(sample) #########################
if batch_array is None:
batch_dimensions = ([len(batch_list)] + [im_shape[0], max_height, max_width])
batch_array = np.zeros(batch_dimensions, dtype= | np.array(im) | numpy.array |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon 20th Apr 2020
@author: christoph
"""
import numpy as np
from tqdm import tqdm
import mom
import pickle
import pandas as pd
import seaborn as sns
import networkx as nx
from sklearn.metrics import mean_squared_error
import matplotlib
import matplotlib.pyplot as plt
import seaborn as sns
np.set_printoptions(linewidth=200)
np.set_printoptions(suppress=True)
def align_columns(A, B):
k = A.shape[1]
G = nx.Graph()
G.add_nodes_from(range(0, k), bipartite=0)
G.add_nodes_from(range(k, k*2), bipartite=1)
elist = []
for i in range(0, k):
for j in range(0, k):
# elist.append((i,k+j,wasserstein_distance(L2[h,:,i],L2R3[h,:,j])))
elist.append((i, k+j, np.abs(A[:, i]-B[:, j]).sum()))
maximum = max(elist, key=lambda t: t[2])[2]
elist = list(map(lambda x: (x[0], x[1], maximum-x[2]), elist))
G.add_weighted_edges_from(elist)
matching = nx.max_weight_matching(G)
sorted_matching = sorted([sorted(pair) for pair in matching])
indexes = np.array(list(map(lambda x: x[1]-k, sorted_matching)))
return indexes
def gen_data(k, c, d, l, alpha0, n):
m = c+d
# Draw alpha
alpha = np.random.randint(1, high=5, size=k)
alpha = alpha / alpha.sum() * alpha0
# Draw theta
beta = np.array([1/d] * d)
theta = np.zeros((k, c+d))
for i in range(k):
# Draw continous parameters
theta[i, :c] = np.random.randint(-10, high=10, size=c)
# Draw discrete parameters
theta[i, c:] = np.random.dirichlet(beta, 1)
# Draw sigma
sigma = np.random.randint(1, high=5, size=k)
# Draw samples
x = np.zeros((n, c+d))
# Sample distribution of topics
omegas = np.random.dirichlet(alpha, n)
for m in tqdm(range(n)):
# Skip randoom document length for easier data handling
# n_w = np.random.poisson(xi)
n_w = l
# Sample how often each topic occurs in the current document
z = | np.random.multinomial(l, omegas[m]) | numpy.random.multinomial |
# SPDX-License-Identifier: BSD-3-Clause
# Copyright (c) 2021 Scipp contributors (https://github.com/scipp)
# flake8: noqa: E501
"""
Tests for data module
"""
# author: <NAME> (arm61)
import os
import unittest
import numpy as np
from numpy.testing import assert_almost_equal, assert_equal
import scipp as sc
from ess.reflectometry import data
from ..tools.io import file_location
np.random.seed(1)
N = 9
VALUES = np.ones(N)
DETECTORS = np.random.randint(1, 5, size=(N))
DATA = sc.DataArray(
data=sc.Variable(
dims=["event"],
unit=sc.units.counts,
values=VALUES,
dtype=sc.dtype.float32,
),
coords={
"detector_id":
sc.Variable(dims=["event"], values=DETECTORS, dtype=sc.dtype.int32)
},
)
DETECTOR_ID = sc.Variable(dims=["detector_id"],
values=np.arange(1, 5),
dtype=sc.dtype.int32)
BINNED = sc.bin(DATA, groups=[DETECTOR_ID])
PIXELS = np.array([[1, 1, 1], [1, 2, 1], [2, 1, 1], [2, 2, 1]])
X = sc.Variable(
dims=["detector_id"],
values=PIXELS[:, 0],
dtype=sc.dtype.float64,
unit=sc.units.m,
)
Y = sc.Variable(
dims=["detector_id"],
values=PIXELS[:, 1],
dtype=sc.dtype.float64,
unit=sc.units.m,
)
Z = sc.Variable(
dims=["detector_id"],
values=PIXELS[:, 2],
dtype=sc.dtype.float64,
unit=sc.units.m,
)
BINNED.coords["position"] = sc.geometry.position(X, Y, Z)
BINNED.attrs['instrument_name'] = sc.scalar(value='AMOR')
BINNED.attrs['experiment_title'] = sc.scalar(value='test')
class TestData(unittest.TestCase):
# Commented out until the sample.nxs file has a home
# def test_refldata_file(self):
# file_path = (os.path.dirname(os.path.realpath(__file__)) +
# os.path.sep + "sample.nxs")
# p = data.ReflData(file_path)
# assert_equal(isinstance(p.data, sc._scipp.core.DataArray), True)
# assert_equal(p.data_file, file_path)
def test_refldata_init(self):
"""
Testing the default initialisation of the ReflData objects.
"""
p = data.ReflData(BINNED.copy())
assert_equal(isinstance(p.data, sc._scipp.core.DataArray), True)
assert_equal(isinstance(p.data.data, sc._scipp.core.Variable), True)
assert_almost_equal(p.data.coords["position"].fields.x.values,
X.values)
assert_almost_equal(p.data.coords["position"].fields.y.values,
Y.values)
assert_almost_equal(p.data.coords["position"].fields.z.values,
Z.values)
assert_almost_equal(
np.sort(
p.data.bins.constituents["data"].coords["detector_id"].values),
np.sort(DETECTORS),
)
assert_almost_equal(
np.sort(p.data.bins.constituents["data"].values),
np.sort(VALUES),
decimal=5,
)
assert_almost_equal(
np.sort(p.data.bins.constituents["data"].variances),
np.sort(np.ones_like(VALUES)),
decimal=5,
)
assert_almost_equal(p.sample_angle_offset.values, 0)
assert_equal(p.sample_angle_offset.unit, sc.units.deg)
def test_refldata_init_sample_angle_offset(self):
"""
Testing the ReflData initialisation with a non-default sample_angle_offset.
"""
p = data.ReflData(BINNED.copy(), sample_angle_offset=2 * sc.units.deg)
assert_almost_equal(p.sample_angle_offset.values, 2)
assert_equal(p.sample_angle_offset.unit, sc.units.deg)
def test_refldata_event(self):
p = data.ReflData(BINNED.copy())
assert_equal(isinstance(p.event, sc._scipp.core.DataArray), True)
assert_almost_equal(np.sort(p.event.coords["detector_id"].values),
np.sort(DETECTORS))
assert_almost_equal(np.sort(p.event.values),
np.sort(VALUES),
decimal=5)
assert_almost_equal(
np.sort(p.event.variances),
np.sort( | np.ones_like(VALUES) | numpy.ones_like |
from typing import Dict, List, Optional, Tuple, Collection, Callable
import networkx as nx
import numpy as np
def bucket_molecules(molecules: List[Dict], keys: List[Callable]) -> Dict:
"""
Organize molecules into nested dictionaries according to molecule properties
specified by the "keys".
The nested dictionary has keys based on the functions used in "keys",
and the innermost value is a list. For example, if
`keys = [
lambda x: x["formula_alphabetical"],
lambda x: len(x.get("bonds", list())),
lambda x: x["charge"]
]`,
then the returned bucket dictionary is something like:
bucket[formula][num_bonds][charge] = [mol_entry1, mol_entry2, ...]
where mol_entry1, mol_entry2, ... have the same formula, number of bonds, and charge.
Args:
entries (List[Dict]): a list of molecule entries to bucket
keys (List[Callable]): each function should return a property of the molecule
Returns:
Dict of molecule entry grouped according to keys.
"""
num_keys = len(keys)
buckets = dict() # type: ignore
for m in molecules:
b = buckets
for i, j in enumerate(keys):
v = j(m)
if i == num_keys - 1:
b.setdefault(v, []).append(m)
else:
b.setdefault(v, {})
b = b[v]
return buckets
def _get_bond_lengths(m):
"""
Args:
m: A dictionary representing a molecule entry in LIBE
Returns:
A list of tuple (species, length), where species are the two species
associated with a bond and length is the corresponding bond length.
"""
coords = m["molecule"].cart_coords
res = list()
for a1, a2 in m["bonds"]:
s1 = m["species"][a1]
s2 = m["species"][a2]
c1 = np.asarray(coords[a1])
c2 = np.asarray(coords[a2])
length = | np.linalg.norm(c1 - c2) | numpy.linalg.norm |
from logging import log
import numpy as np
import pandas as pd
from scipy import interpolate
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import (FigureCanvasTkAgg, NavigationToolbar2Tk)
from matplotlib.backend_bases import key_press_handler
from matplotlib.figure import Figure
from matplotlib.font_manager import FontProperties
from matplotlib.ticker import ScalarFormatter
from flask import Flask, render_template, request
from tkinter import *
from tkinter import ttk
import sys
import os
import shutil
import random
from matplotlib.ticker import MaxNLocator
from pathlib import Path
import math
import copy
#from decimal import Decimal, ROUND_HALF_UP
def readinput(filename):
csv_input = pd.read_csv(filepath_or_buffer=filename, encoding="utf_8", sep=",")
symbol = csv_input['Symbol']
value = csv_input['Value']
unit = csv_input['Unit']
valueDict = {}
unitDict = {}
for i, j, k in zip(symbol, value, unit):
valueDict[i] = float(j)
unitDict[i] = str(k)
return valueDict, unitDict
def CeqLHVFunc(filename,fuelName):
csv_input = pd.read_csv(filepath_or_buffer=filename, encoding="utf_8", sep=",")
fuelType = csv_input['Fuel type']
CeqLHV = csv_input['CeqLHV']
fuelDict = {}
for i, j in zip(fuelType, CeqLHV):
fuelDict[i] = float(j)
return fuelDict[fuelName]
def Cco2Func(filename,fuelName):
csv_input = pd.read_csv(filepath_or_buffer=filename, encoding="utf_8", sep=",")
fuelType = csv_input['Fuel type']
Cco2 = csv_input['Cco2']
Cco2Dict = {}
for i, j in zip(fuelType, Cco2):
Cco2Dict[i] = float(j)
return Cco2Dict[fuelName]
def initialFleetFunc(filename):
csv_input = pd.read_csv(filepath_or_buffer=filename, encoding="utf_8", sep=",")
year = csv_input['Year']
TEU = csv_input['TEU']
iniFleetDict = {}
k = 0
for i, j in zip(year, TEU):
iniFleetDict.setdefault(k,{})
iniFleetDict[k]['year'] = int(i)
iniFleetDict[k]['TEU'] = float(j)
k += 1
return iniFleetDict
def decisionListFunc(filename):
csv_input = pd.read_csv(filepath_or_buffer=filename, encoding="utf_8", sep=",").fillna(0)
Year = csv_input['Year']
Order = csv_input['Order']
fuelType = csv_input['Fuel type']
WPS = csv_input['WPS']
SPS = csv_input['SPS']
CCS = csv_input['CCS']
CAP = csv_input['CAP']
Speed = csv_input['Speed']
Fee = csv_input['Fee']
valueDict = {}
for i, j, k, l, m, n, o, p, q in zip(Year, Order, fuelType, WPS, SPS, CCS, CAP, Speed, Fee):
valueDict.setdefault(int(i),{})
valueDict[int(i)]['Order'] = int(j)
valueDict[int(i)]['fuelType'] = k
valueDict[int(i)]['WPS'] = int(l)
valueDict[int(i)]['SPS'] = int(m)
valueDict[int(i)]['CCS'] = int(n)
valueDict[int(i)]['CAP'] = float(o)
valueDict[int(i)]['Speed'] = float(p)
valueDict[int(i)]['Fee'] = float(q)
return valueDict
def fleetPreparationFunc(fleetAll,initialFleetFile,numCompany,startYear,lastYear,elapsedYear,tOpSch,tbid,valueDict,NShipFleet,parameterFile2,parameterFile12,parameterFile3,parameterFile5):
fleetAll.setdefault(numCompany,{})
fleetAll[numCompany].setdefault('total',{})
fleetAll[numCompany]['total']['sale'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['g'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['gTilde'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['costTilde'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['saleTilde'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['cta'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['overDi'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['costShipBasicHFO'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['costShip'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['costFuel'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['dcostFuel'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['costAdd'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['costAll'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['maxCta'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['rocc'] = np.zeros(lastYear-startYear+1)
fleetAll[numCompany]['total']['costRfrb'] = | np.zeros(lastYear-startYear+1) | numpy.zeros |
import time
import random
import itertools
# import gc
import os
import sys
import datetime
import numpy as np
import yaml
import pickle
from operator import itemgetter
from optparse import OptionParser
from sklearn.model_selection import KFold
from sklearn.metrics import roc_curve, auc, average_precision_score
sys.path.insert(0, os.path.join(sys.path[0], ".."))
from tiknib.utils import do_multiprocess, parse_fname
from tiknib.utils import load_func_data
from tiknib.utils import flatten
from tiknib.utils import store_cache
from tiknib.utils import load_cache
from get_roc_graph import plot_roc_all
import logging
import coloredlogs
logger = logging.getLogger(__name__)
coloredlogs.install(level=logging.INFO)
coloredlogs.install(level=logging.DEBUG)
np.seterr(divide="ignore", invalid="ignore")
def debughere():
import ipdb; ipdb.set_trace(sys._getframe().f_back)
def get_package(func_key):
return func_key[0]
def get_binary(func_key):
return func_key[1]
def get_func(func_key):
return (func_key[2], func_key[3])
def get_opti(option_key):
return option_key[0]
def get_arch(option_key):
return option_key[1]
def get_arch_nobits(option_key):
return option_key[1].split("_")[0]
def get_bits(option_key):
return option_key[1].split("_")[1]
def get_compiler(option_key):
return option_key[2]
def get_others(option_key):
return option_key[3]
def parse_other_options(bin_path):
other_options = ["lto", "pie", "noinline"]
for opt in other_options:
if opt in bin_path:
return opt
return "normal"
def get_optionidx_map(options):
return {opt: idx for idx, opt in enumerate(sorted(options))}
def is_valid(dictionary, s):
return s in dictionary and dictionary[s]
def load_options(config):
options = ["opti", "arch", "compiler", "others"]
src_options = []
dst_options = []
fixed_options = []
for idx, opt in enumerate(options):
src_options.append(config["src_options"][opt])
dst_options.append(config["dst_options"][opt])
if is_valid(config, "fixed_options") and opt in config["fixed_options"]:
fixed_options.append(idx)
src_options = set(itertools.product(*src_options))
dst_options = set(itertools.product(*dst_options))
options = sorted(src_options.union(dst_options))
optionidx_map = get_optionidx_map(options)
dst_options_filtered = {}
# Filtering dst options
for src_option in src_options:
def _check_option(opt):
if opt == src_option:
return False
for idx in fixed_options:
if opt[idx] != src_option[idx]:
return False
return True
candidates = list(filter(_check_option, dst_options))
# arch needs more filtering ...
# - 32 vs 64 bits
# - little vs big endian
# need to have same archs without bits
# TODO: move this file name checking into config option.
if "arch_bits" in config["fname"]:
def _check_arch_without_bits(opt):
return get_arch_nobits(opt) == get_arch_nobits(src_option)
candidates = list(filter(_check_arch_without_bits, candidates))
# need to have same bits
elif "arch_endian" in config["fname"]:
def _check_bits(opt):
return get_bits(opt) == get_bits(src_option)
candidates = list(filter(_check_bits, candidates))
candidates = list(set([optionidx_map[opt] for opt in candidates]))
dst_options_filtered[optionidx_map[src_option]] = candidates
logger.info("total %d options.", len(options))
logger.info("%d src options.", len(src_options))
logger.info("%d dst options.", len(dst_options))
logger.info("%d filtered dst options.", len(dst_options_filtered))
return options, dst_options_filtered
def pre_k(ranks, k):
count = 0
for r in ranks:
if r <= k:
count += 1
return count / len(ranks)
def analyze_top_k_results(config, all_data):
for target_key in all_data:
logger.info("Analyzing %s", target_key)
all_ranks=[]
all_funcs=[]
for target_option in all_data[target_key]:
result_arch, result, scores = all_data[target_key][target_option]
ranks, func_counts, other_ranks = result_arch
ranks = list(ranks.values())
func_counts = list(func_counts.values())
logger.info("Top-K %s(%s)", target_key, target_option)
logger.info("Avg Rank: %0.4f", np.mean(ranks))
logger.info("Std Rank: %0.4f", np.std(ranks))
logger.info("Prec Top 1: %0.4f", pre_k(ranks,1))
logger.info("Prec Top 10: %0.4f", pre_k(ranks,10))
logger.info("Prec Top 100: %0.4f", pre_k(ranks,100))
logger.info("Avg Counts: %0.4f", np.mean(func_counts))
all_ranks.extend(ranks)
all_funcs.extend(func_counts)
logger.info("Top-K %s", target_key)
logger.info("Avg Rank: %0.4f", np.mean(all_ranks))
logger.info("Std Rank: %0.4f", np.std(all_ranks))
logger.info("Prec Top 1: %0.4f", pre_k(all_ranks,1))
logger.info("Prec Top 10: %0.4f", pre_k(all_ranks,10))
logger.info("Prec Top 100: %0.4f", pre_k(all_ranks,100))
logger.info("Avg Counts: %0.4f", np.mean(all_funcs))
logger.info("============= normal feature set=============")
for target_key in all_data:
logger.info("Analyzing %s", target_key)
all_ranks=[]
all_funcs=[]
for target_option in all_data[target_key]:
result_arch, result, scores = all_data[target_key][target_option]
ranks, func_counts, other_ranks = result
ranks = list(ranks.values())
func_counts = list(func_counts.values())
logger.info("Top-K %s(%s)", target_key, target_option)
logger.info("Avg Rank: %0.4f", np.mean(ranks))
logger.info("Std Rank: %0.4f", | np.std(ranks) | numpy.std |
# Copyright 2021 The Cirq Developers
#
# 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
#
# https://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.
from typing import Any, Mapping, Optional, Sequence, Union, SupportsFloat
import numpy as np
from matplotlib import pyplot as plt
def integrated_histogram(
data: Union[Sequence[SupportsFloat], Mapping[Any, SupportsFloat]],
ax: Optional[plt.Axes] = None,
*,
cdf_on_x: bool = False,
axis_label: str = '',
semilog: bool = True,
median_line: bool = True,
median_label: Optional[str] = 'median',
mean_line: bool = False,
mean_label: Optional[str] = 'mean',
show_zero: bool = False,
title: Optional[str] = None,
**kwargs,
) -> plt.Axes:
"""Plot the integrated histogram for an array of data.
Suppose the input is a list of gate fidelities. The x-axis of the plot will
be gate fidelity, and the y-axis will be the probability that a random gate
fidelity from the list is less than the x-value. It will look something like
this
1.0
| |
| ___|
| |
| ____|
| |
| |
|_____|_______________
0.0
Another way of saying this is that we assume the probability distribution
function (pdf) of gate fidelities is a set of equally weighted delta
functions at each value in the list. Then, the "integrated histogram"
is the cumulative distribution function (cdf) for this pdf.
Args:
data: Data to histogram. If the data is a `Mapping`, we histogram the
values. All nans will be removed.
ax: The axis to plot on. If None, we generate one.
cdf_on_x: If True, flip the axes compared the above example.
axis_label: Label for x axis (y-axis if cdf_on_x is True).
semilog: If True, force the x-axis to be logarithmic.
median_line: If True, draw a vertical line on the median value.
median_label: If drawing median line, optional label for it.
mean_line: If True, draw a vertical line on the mean value.
mean_label: If drawing mean line, optional label for it.
title: Title of the plot. If None, we assign "N={len(data)}".
show_zero: If True, moves the step plot up by one unit by prepending 0
to the data.
**kwargs: Kwargs to forward to `ax.step()`. Some examples are
color: Color of the line.
linestyle: Linestyle to use for the plot.
lw: linewidth for integrated histogram.
ms: marker size for a histogram trace.
label: An optional label which can be used in a legend.
Returns:
The axis that was plotted on.
"""
show_plot = not ax
if ax is None:
fig, ax = plt.subplots(1, 1)
if isinstance(data, Mapping):
data = list(data.values())
data = [d for d in data if not np.isnan(d)]
n = len(data)
if not show_zero:
bin_values = | np.linspace(0, 1, n + 1) | numpy.linspace |
# -*- coding: utf-8 -*-
"""
Reference: http://www.marine.csiro.au/~dunn/cars2009/
Evaluate at day-of-year 45 (mid February)
t = 2pi x 45/366
feb = mean + an_cos*cos(t) + an_sin*sin(t) + sa_cos*cos(2*t) + sa_sin*sin(2*t)
download_file('http://www.marine.csiro.au/atlas/export/temperature_cars2009a.nc.gz', '755ec973e4d9bd05de202feb696704c2')
download_file('http://www.marine.csiro.au/atlas/export/salinity_cars2009a.nc.gz', '7f78173f4ef2c0a4ff9b5e52b62dc97d')
"""
from os.path import expanduser
import re
from datetime import datetime
import numpy as np
from numpy import ma
import os
from oceansdb.utils import dbsource
try:
import netCDF4
except:
print("netCDF4 is not available")
# try:
# from pydap.client import open_url
# import pydap.lib
# pydap.lib.CACHE = expanduser('~/.cotederc/pydap_cache')
# except:
# print("PyDAP is not available")
from scipy.interpolate import interp1d
# RectBivariateSpline
from scipy.interpolate import griddata
def extract(filename, doy, latitude, longitude, depth):
"""
For now only the closest value
For now only for one position, not an array of positions
longitude 0-360
"""
assert np.size(doy) == 1
assert np.size(latitude) == 1
assert np.size(longitude) == 1
assert np.size(depth) == 1
assert (longitude >= 0) & (longitude <= 360)
assert depth >= 0
nc = netCDF4.Dataset(filename)
t = 2 * np.pi * doy/366
Z = np.absolute(nc['depth'][:] - depth).argmin()
I = np.absolute(nc['lat'][:] - latitude).argmin()
J = np.absolute(nc['lon'][:] - longitude).argmin()
# Naive solution
value = nc['mean'][:, I, J]
value[:64] += nc['an_cos'][Z, I, J] * np.cos(t) + \
nc['an_sin'][:, I, J] * np.sin(t)
value[:55] += nc['sa_cos'][Z, I, J] * np.cos(2*t) + \
nc['sa_sin'][:, I, J] * np.sin(2*t)
value = value[Z]
std = nc['std_dev'][Z, I, J]
return value, std
def cars_profile(filename, doy, latitude, longitude, depth):
"""
For now only the closest value
For now only for one position, not an array of positions
longitude 0-360
"""
assert np.size(doy) == 1
assert np.size(latitude) == 1
assert np.size(longitude) == 1
#assert np.size(depth) == 1
assert (longitude >= 0) & (longitude <= 360)
assert depth >= 0
nc = netCDF4.Dataset(filename)
t = 2 * np.pi * doy/366
# Improve this. Optimize to get only necessary Z
Z = slice(0, nc['depth'].size)
I = np.absolute(nc['lat'][:] - latitude).argmin()
J = np.absolute(nc['lon'][:] - longitude).argmin()
# Not efficient, but it works
assert (nc['depth'][:64] == nc['depth_ann'][:]).all()
assert (nc['depth'][:55] == nc['depth_semiann'][:]).all()
value = nc['mean'][:, I, J]
value[:64] += nc['an_cos'][Z, I, J] * np.cos(t) + \
nc['an_sin'][:, I, J] * np.sin(t)
value[:55] += nc['sa_cos'][Z, I, J] * np.cos(2*t) + \
nc['sa_sin'][:, I, J] * np.sin(2*t)
value = value
output = {'depth': np.asanyarray(depth)}
from scipy.interpolate import griddata
output['value'] = griddata(nc['depth'][Z], value[Z], depth)
for v in ['std_dev']:
output[v] = griddata(nc['depth'][Z], nc[v][Z, I, J], depth)
return output
class CARS_var_nc(object):
"""
Reads the CARS Climatology NetCDF file and
returns the corresponding values of salinity or temperature mean and
standard deviation for the given time, lat, lon, depth.
"""
def __init__(self, source):
import netCDF4
self.ncs = []
for s in source:
self.ncs.append(netCDF4.Dataset(s, 'r'))
self.load_dims()
self.set_keys()
def keys(self):
return self.KEYS
def load_dims(self):
self.dims = {}
for d in ['lat', 'lon', 'depth']:
self.dims[d] = self.ncs[0].variables[d][:]
for nc in self.ncs[1:]:
assert (self.dims[d] == nc.variables[d][:]).all()
#self.dims['time'] = []
#mfrac = 365/12.
#for nc in self.ncs:
# assert nc.variables['time'].size == 1
# self.dims['time'].append(mfrac * nc.variables['time'][0])
self.dims['time'] = np.array([])
def set_keys(self):
"""
"""
self.KEYS = ['mn']
for v in self.ncs[0].variables.keys():
if self.ncs[0].variables[v].dimensions == \
(u'depth', u'lat', u'lon'):
S = self.ncs[0].variables[v].shape
for nc in self.ncs[1:]:
assert v in nc.variables
assert nc.variables[v].shape == S
self.KEYS.append(v)
def __getitem__(self, item):
if item in self.KEYS:
return self.ncs[0].variables[item]
elif re.match('(?:[s,t]_)?sd', item):
return self.ncs[0].variables['std_dev']
elif re.match('(?:[s,t]_)?dd', item):
return self.ncs[0].variables['nq']
return "yooo"
def closest(self, doy, depth, lat, lon, var):
tn = (np.abs(doy - self.dims['time'][:])).argmin()
zn = [(np.abs(z - self.dims['depth'][:])).argmin() for z in depth]
yn = (np.abs(lat - self.dims['lat'][:])).argmin()
# FIXME
xn = (np.abs(lon - self.dims['lon'][:])).argmin()
subset = {}
for v in var:
if v in self.KEYS:
subset[v] = self.ncs[tn][v][0, zn, yn, xn]
else:
# FIXME: Ugly temporary solution
tmp = [vv for vv in self.KEYS if vv[2:] == v]
assert len(tmp) == 1
subset[v] = self.ncs[tn][tmp[0]][0, zn, yn, xn]
return subset
def subset(self, doy, depth, lat, lon, var):
""" Subset the necessary data to interpolate in the right position
Special cases that should be handled here:
0 to 360 versus -180 to 180
position near grenwich, or international date line
"""
dims = {}
zn = slice(
np.nonzero(self.dims['depth'] <= depth.min())[0].max(),
np.nonzero(
self.dims['depth'] >=
min(self.dims['depth'].max(), depth.max())
)[0].min() + 1
)
# If a higher degree interpolation system uses more than one data
# point in the edge, I should extend this selection one point on
# each side, without go beyond 0
# if zn.start < 0:
# zn = slice(0, zn.stop, zn.step)
dims['depth'] = np.atleast_1d(self.dims['depth'][zn])
yn = slice(
np.nonzero(self.dims['lat'] <= lat.min())[0].max(),
np.nonzero(self.dims['lat'] >= lat.max())[0].min() + 1)
dims['lat'] = np.atleast_1d(self.dims['lat'][yn])
lon_ext = np.array(
(self.dims['lon'] - 360).tolist() +
self.dims['lon'].tolist() +
(self.dims['lon']+360).tolist())
xn_ext = np.array(3 * list(range(self.dims['lon'].shape[0])))
xn_start = np.nonzero(lon_ext <= lon.min())[0].max()
xn_end = np.nonzero(lon_ext >= lon.max())[0].min()
xn = xn_ext[xn_start:xn_end+1]
dims['lon'] = | np.atleast_1d(lon_ext[xn_start:xn_end+1]) | numpy.atleast_1d |
"""Module for testing helper functions."""
from pytest import approx
import numpy as np
import tensorflow as tf
from ..functions import log_loss
def test_log_loss(sample_predictions):
tf.reset_default_graph()
session = tf.Session()
y_true, y_pred = sample_predictions
def calc_log_loss(true_pred, pred):
log_loss = (-true_pred * np.log(pred)) - (
(1 - true_pred) * | np.log(1 - pred) | numpy.log |
import os
import pickle
import logging
import inspect
from abc import ABC
import numpy as np
from barry.datasets.dataset import Dataset
class CorrelationFunction(Dataset, ABC):
def __init__(self, filename, name=None, min_dist=30, max_dist=200, recon=True, reduce_cov_factor=1, realisation=None):
current_file = os.path.dirname(inspect.stack()[0][1])
self.data_location = os.path.normpath(current_file + f"/../data/{filename}")
self.min_dist = min_dist
self.max_dist = max_dist
self.recon = recon
with open(self.data_location, "rb") as f:
self.data_obj = pickle.load(f)
name = name or self.data_obj["name"] + " Recon" if recon else " Prerecon"
super().__init__(name)
self.cosmology = self.data_obj["cosmology"]
self.all_data = self.data_obj["post-recon"] if recon else self.data_obj["pre-recon"]
self.reduce_cov_factor = reduce_cov_factor
if self.reduce_cov_factor == -1:
self.reduce_cov_factor = len(self.all_data)
self.logger.info(f"Setting reduce_cov_factor to {self.reduce_cov_factor}")
self.cov, self.icov, self.data, self.mask = None, None, None, None
self.set_realisation(realisation)
self._compute_cov()
def set_realisation(self, realisation):
if realisation is None:
self.data = np.array(self.all_data).mean(axis=0)
else:
self.data = self.all_data[realisation]
self.mask = (self.data[:, 0] >= self.min_dist) & (self.data[:, 0] <= self.max_dist)
self.data = self.data[self.mask, :]
def set_cov(self, cov):
self.cov = cov / self.reduce_cov_factor
self.icov = np.linalg.inv(self.cov)
def _compute_cov(self):
# TODO: Generalise for other multipoles poles
ad = | np.array(self.all_data) | numpy.array |
# change random iteration methods to work with scipy optimize way more methods avalible
"""
#TODO:
Sort out documentation for each method
"""
import typing
import warnings
from collections import defaultdict
import numpy as np
import scipy.stats
from scipy.optimize import minimize
from scipy.signal import fftconvolve
from numba import njit
from .ACF_class import ACF
from .Surface_class import Surface, _Surface
from ._johnson_utils import _fit_johnson_by_moments, _fit_johnson_by_quantiles
__all__ = ['RandomFilterSurface', 'RandomPerezSurface']
class RandomPerezSurface(_Surface):
""" Surfaces with set height distribution and PSD found by the Perez method
Parameters
----------
target_psd: np.ndarray
The PSD which the surface will approximate, the shape of the surface will be the same as the psd array
(the same number of points in each direction)
height_distribution: {scipy.stats.rv_continuous, sequence}
Either a scipy.stats distribution or a sequence of the same size as the required output
accuracy: float, optional (1e-3)
The accuracy required for the solution to be considered converged, see the notes of the discretise method for
more information
max_it: int, optional (100)
The maximum number of iterations used to discretise a realisation
min_speed: float, optional (1e-10)
The minimum speed of the iterations, if the iterations are converging slower than this they are deemed not to
converge
generate: bool, optional (False)
If True the surface profile is found on instantiation
grid_spacing: float, optional (None)
The distance between grid points on the surface
exact: {'psd', 'heights', 'best'}, optional ('best')
Notes
-----
This method iterates between a surface with the exact right height distribution and one with the exact right PSD
this method is not guaranteed to converge for all surfaces, for more details see the reference.
Examples
--------
Making a surface with a normal height distribution and a given power spectra.
>>> import numpy as np
>>> import scipy.stats as stats
>>> import slippy.surface as s
>>> # making a surface with an exponential ACF as described in the original paper:
>>> beta = 10 # the drop off length of the acf
>>> sigma = 1 # the roughness of the surface
>>> qx = np.arange(-128,128)
>>> qy = np.arange(-128,128)
>>> Qx, Qy = np.meshgrid(qx,qy)
>>> Cq = sigma**2*beta/(2*np.pi*(beta**2+Qx**2+Qy**2)**0.5) # the PSD of the surface
>>> Cq = np.fft.fftshift(Cq)
>>> height_distribution = stats.norm()
>>> my_surface = s.RandomPerezSurface(target_psd = Cq, height_distribution=height_distribution,
>>> grid_spacing=1,
>>> generate=True)
>>> my_surface.show()
References
----------
Based on the method and code given in:
<NAME>, <NAME>,
Generating randomly rough surfaces with given height probability distribution and power spectrum,
Tribology International,
Volume 131,
2019,
Pages 591-604,
ISSN 0301-679X,
https://doi.org/10.1016/j.triboint.2018.11.020.
(http://www.sciencedirect.com/science/article/pii/S0301679X18305607)
"""
dist: scipy.stats.rv_continuous = None
_rvs: np.ndarray = None
def __init__(self, target_psd: np.ndarray,
height_distribution: typing.Union[scipy.stats.rv_continuous, typing.Sequence] = None,
accuracy: float = 1e-3, max_it: int = 100, min_speed: float = 1e-10,
generate: bool = False, grid_spacing: float = None, exact: str = 'best'):
super().__init__(grid_spacing, None, None)
self._target_psd = target_psd
if height_distribution is None:
height_distribution = scipy.stats.norm()
try:
if hasattr(height_distribution, 'rvs'):
self.dist = height_distribution
elif len(height_distribution) == target_psd.size or height_distribution.size == target_psd.size:
self._rvs = np.array(height_distribution).flatten()
except AttributeError:
raise ValueError('Unrecognised type for height distribution')
self._accuracy = accuracy
self._max_it = max_it
self._min_speed = min_speed
if exact not in {'psd', 'heights', 'best'}:
raise ValueError("exact not recognised should be one of {'psd', 'heights', 'best'}")
self._exact = exact
if generate:
self.discretise()
def __repr__(self):
pass
def discretise(self, return_new: bool = False, accuracy: float = None, max_it: int = None, min_speed: float = None,
suppress_errors: bool = False, return_original: bool = False):
"""Discretise the surface with a realisation
Parameters
----------
return_new: bool, optional (False)
If True a new surface is returned else Nothing is returned and the profile property of the surface is set
accuracy: float, optional (None)
The tolerance used to detect convergence of the psd and height distribution, if not set defaults to the
value set on initialisation
max_it: int, optional (None)
The maximum number of iterations used to fit the PSD and height spectra, if not set defaults to the value
set on initialisation
min_speed: float, optional (None)
The minimum speed which the iterations can be converging before they are stopped (assumed to be not
converging), if not set defaults to the value set on initialisation
suppress_errors: bool, optional (False)
If True convergence errors are suppressed and the profile realisation is made even if the solution has not
converged, warnings are produced
return_original: bool, optional (False)
If True the variables returned by the original code given in the paper are returned, these are: the
estimated surface with the correct height distribution, the estimated surface with the correct PSD and a
dict of errors with each element being a list of error values with one value for each iteration.
Returns
-------
Will return a new surface object if the return_new argument is True, otherwise sets the profile property of the
parent surface
Will return two surface estimates and a dict of errors if return_original is True
Examples
--------
>>> import numpy as np
>>> import scipy.stats as stats
>>> import slippy.surface as s
>>> # making a surface with an exponential ACF as described in the original paper:
>>> beta = 10 # the drop off length of the acf
>>> sigma = 1 # the roughness of the surface
>>> qx = np.arange(-128,128)
>>> qy = np.arange(-128,128)
>>> Qx, Qy = np.meshgrid(qx,qy)
>>> Cq = sigma**2*beta/(2*np.pi*(beta**2+Qx**2+Qy**2)**0.5) # the PSD of the surface
>>> height_distribution = stats.norm()
>>> my_surface = s.RandomPerezSurface(target_psd = Cq, height_distribution=height_distribution, grid_spacing=1)
>>> my_surface.discretise()
>>> my_surface.show()
Zh, Zs, error = fractal_surf_generator(np.fft.ifftshift(Cq),
np.random.randn(256,256),
min_speed = 1e-10,max_error=0.01)
Notes
-----
During iteration of this solution two surfaces are maintained, one which has the correct PSD and one which has
the correct height distribution, the one returned is the one which was first deemed to have converged. To over
ride this behaviour set return original to True
References
----------
<NAME>, <NAME>,
Generating randomly rough surfaces with given height probability distribution and power spectrum,
Tribology International,
Volume 131,
2019,
Pages 591-604,
ISSN 0301-679X,
https://doi.org/10.1016/j.triboint.2018.11.020.
(http://www.sciencedirect.com/science/article/pii/S0301679X18305607)
"""
if return_original and return_new:
raise ValueError("Only one of return_new and return_original can be set to True")
accuracy = self._accuracy if accuracy is None else accuracy
max_it = self._max_it if max_it is None else max_it
min_speed = self._min_speed if min_speed is None else min_speed
# scale and centre the PSD
power_spectrum = self._target_psd
m, n = power_spectrum.shape
power_spectrum[0, 0] = 0
power_spectrum = power_spectrum / np.sqrt(np.sum(power_spectrum.flatten() ** 2)) * m * n
# generate random values for the surface
if self.dist is not None:
height_distribution = self.dist.rvs(power_spectrum.shape).flatten()
elif self._rvs is not None:
height_distribution = self._rvs
else:
raise ValueError("Height distribution not set, cannot descretise")
# scale and centre the height probability distribution
mean_height = np.mean(height_distribution.flatten())
height_guess = height_distribution - mean_height
sq_roughness = np.sqrt(np.mean(height_guess.flatten() ** 2))
height_guess = height_guess / sq_roughness
# sort height dist
index_0 = np.argsort(height_guess.flatten())
sorted_target_heights = height_guess.flatten()[index_0]
# find bins for height distribution error
bin_width = 3.5 * sorted_target_heights.size ** (-1 / 3) # Scott bin method *note that the
# values are normalised to have unit standard deviation
n_bins = int(np.ceil((sorted_target_heights[-1] - sorted_target_heights[0]) / bin_width))
bin_edges = np.linspace(sorted_target_heights[0], sorted_target_heights[-1], n_bins + 1)
n0, bin_edges = np.histogram(sorted_target_heights, bins=bin_edges, density=True)
error = defaultdict(list)
height_guess = height_guess.reshape(power_spectrum.shape)
fft_height_guess = np.fft.fft2(height_guess)
best = 'psd'
while True:
# Step 1: fix power spectrum by FFT filter
# Zs = np.fft.ifft2(zh*power_spectrum/Ch)
phase = np.angle(fft_height_guess)
# phase = _conj_sym(phase, neg=True)
psd_guess = np.fft.ifft2(power_spectrum * np.exp(1j * phase)).real
# find error in height distribution
n_hist, _ = np.histogram(psd_guess.flatten(), bin_edges, density=True)
error['H'].append(np.sum(np.abs(n_hist - n0) * (bin_edges[1:] - bin_edges[:-1])))
# Step 2: Fix the height distribution rank ordering
height_guess = psd_guess.flatten()
index = np.argsort(height_guess)
height_guess[index] = sorted_target_heights
height_guess = height_guess.reshape((m, n))
fft_height_guess = np.fft.fft2(height_guess)
# find error in the power spectrum
fft_hg_abs = np.abs(fft_height_guess)
# Ch = np.abs(zh**2)#*grid_spacing**2/(n*m*(2*np.pi)**2)
error['PS'].append(np.sqrt(np.mean((1 - fft_hg_abs[power_spectrum > 0] /
power_spectrum[power_spectrum > 0]) ** 2)))
error['PS0'].append(np.sqrt(np.mean(fft_hg_abs[power_spectrum == 0] ** 2)) /
np.mean(power_spectrum[power_spectrum > 0]))
if len(error['H']) >= max_it:
msg = 'Iterations for fractal surface failed to converge in the set number of iterations'
break
if len(error['H']) > 2 and abs(error['H'][-1] - error['H'][-2]) / error['H'][-1] < min_speed:
msg = ('Solution for fractal surface convering is converging '
'slower than the minimum speed, solution failed to converge')
break
if len(error['H']) > 2 and (error['H'][-2] - error['H'][-1]) < 0:
msg = 'Solution is diverging, solution failed to converge'
break
if error['H'][-1] < accuracy:
msg = ''
best = 'heights'
break
if error['PS'][-1] < accuracy and error['PS0'][-1] < accuracy:
msg = ''
best = 'psd'
break # solution converged
if msg:
if suppress_errors:
warnings.warn(msg)
else:
raise StopIteration(msg)
exact = self._exact if self._exact != 'best' else best
if exact == 'psd':
profile = psd_guess * sq_roughness + mean_height
else:
profile = height_guess * sq_roughness + mean_height
if return_new:
return Surface(profile=profile, grid_spacing=self.grid_spacing)
if return_original:
return height_guess, psd_guess, error
self.profile = profile
class RandomFilterSurface(_Surface):
r""" Surfaces based on transformations of random sequences by a filter
Filter coefficients can be found by fourier analysis or solving the least squares problem given by Patir.
Parameters
----------
target_acf: slippy.surface.ACF
An ACF object describing the trage autocorrelation function of the surface
grid_spacing: float, optional (None)
The distance between surface points, must be set before the filter coefficients can be found
extent: 2 element sequence of floats, optional (None)
The total size of the surface in the same units as the grid spacing
shape: 2 element sequence of ints, optional (None)
The number of points in each direction on the surface
Attributes
----------
dist : scipy.stats.rv_continuous
The statistical distribution which the random sequence is drawn from
Methods
-------
linear_transforms: find filter coefficients by Patir's method (with extentions)
fir_filter: find filter coefficients by Hu and Tonder's method
set_moments
set_quantiles
discretise
See Also
--------
surface_like
Notes
-----
This is a subclass of Surface and inherits all methods. All key words that
can be passed to Surface on instantiation can also be passed to this class
apart from 'profile'
Examples
--------
In the following example we will generate a randomly rough surface with an exponential ACF and a non gaussian height
distribution.
>>> import slippy.surface as s # surface generation and manipulation
>>> import numpy as np # numerical functions
>>> np.random.seed(0)
>>> target_acf = s.ACF('exp', 2, 0.1, 0.2) # make an example ACF
>>> # Finding the filter coefficients
>>> lin_trans_surface = s.RandomFilterSurface(target_acf=target_acf, grid_spacing=0.01)
>>> lin_trans_surface.linear_transform(filter_shape=(40,20), gtol=1e-5, symmetric=True)
>>> # Setting the skew and kurtosis of the output surface
>>> lin_trans_surface.set_moments(skew = -0.5, kurtosis=5)
>>> # generating and showing a realisation of the surface
>>> my_realisation = lin_trans_surface.discretise([512,512], periodic=False, create_new=True)
>>> fig, axes = my_realisation.show(['profile', 'acf', 'histogram'], ['image', 'image'], figsize=(15,5))
References
----------
<NAME>., & <NAME>. (1992). Simulation of 3-D random rough surface by 2-D digital filter and Fourier analysis.
International Journal of Machine Tools, 32(1–2), 83–90.
doi.org/10.1016/0890-6955(92)90064-N
<NAME>. (1978). A numerical procedure for random generation of rough surfaces. Wear, 47(2), 263–277.
doi.org/10.1016/0043-1648(78)90157-6
<NAME>., <NAME>., & <NAME>. (2020). Improvements to the linear transform technique for generating randomly
rough surfaces with symmetrical autocorrelation functions. Tribology International, 151(April), 106487.
doi.org/10.1016/j.triboint.2020.106487
"""
surface_type = 'Random'
dist = scipy.stats.norm(loc=0, scale=1)
_filter_coefficients: np.ndarray = None
target_acf: ACF = None
is_discrete: bool = False
_moments = None
_method_keywords = None
target_acf_array = None
"An array of acf values used as the target for the fitting procedure"
def __init__(self,
target_acf: ACF = None,
grid_spacing: typing.Optional[float] = None,
extent: typing.Optional[typing.Sequence] = None,
shape: typing.Optional[typing.Sequence] = None):
super().__init__(grid_spacing=grid_spacing, extent=extent, shape=shape)
if target_acf is not None:
self.target_acf = target_acf
def __repr__(self):
string = 'RandomFilterSurface('
if self.target_acf is not None:
string += f'target_acf={repr(self.target_acf)}, '
string += f'grid_spacing={self.grid_spacing}, '
if self._moments is not None:
string += f'moments = {self._moments}, '
if self.shape is not None:
string += f'shape = {self.shape}, '
string = string[:-2]
return string + ')'
def linear_transform(self, filter_shape: typing.Sequence = (14, 14), symmetric: bool = True, max_it: int = None,
gtol: float = 1e-5, method='BFGS', **minimize_kwargs):
r"""
Generates a linear transform matrix
Solves the non linear optimisation problem to generate a
moving average filter that when convolved with a set of normally
distributed random numbers will generate a surface profile with the
specified ACF
Parameters
----------
filter_shape: Sequence, optional (14, 14)
The dimensions of the filter coefficient matrix to be generated the default is (35, 35), must be exactly 2
elements both elements must be ints
symmetric: bool, optional (True)
If true a symmetric filter will be fitted to the target ACF, this typically produces more realistic surfaces
for the same filter shape but takes longer to fit the filter
max_it: int, optional (100)
The maximum number of iterations used
gtol: float, optional (1e-11)
The accuracy of the iterated solution
method: str, optional ('BFGS')
Type of solver. In most situations this should be one of the following:
- Nelder-Mead
- Powell
- CG
- BFGS
- Newton-CG
However other options exist, see the notes for more details
minimize_kwargs
Extra key word arguments which are passed to scipy.optimise.minimize function, valid arguments will depend
on the choice of method
Returns
-------
None
Sets the filter_coefficients property of the instance
See Also
--------
RandomFilterSurface.set_moments
RandomFilterSurface.FIRfilter
Notes
-----
This problem has a unique solution for each grid spacing. This should
be set before running this method, else it is assumed to be 1.
For more information on each of the methods available the documentation of scipy.optimize.minimize should be
consulted. Practically, for this problem only unconstrained, unbound solvers are appropriate, these are:
- Nelder-Mead
- Powell
- CG
- BFGS
- Newton-CG
- dogleg
- trust-ncg
- trust-krylov
- trust-exact
However, the dogleg, trust-ncg, trust-krylov, trust-exact additionally require the user to specify the hessian
matrix for the problem which is currently unsupported.
References
----------
..[1] <NAME>, "A numerical procedure for random generation of
rough surfaces (1978)"
Wear, 47(2), 263–277.
'<https://doi.org/10.1016/0043-1648(78)90157-6>'_
Examples
--------
In the following example we will generate a randomly rough surface with an exponential ACF and a non gaussian
height distribution.
>>> import slippy.surface as s # surface generation and manipulation
>>> import numpy as np # numerical functions
>>> np.random.seed(0)
>>> target_acf = s.ACF('exp', 2, 0.1, 0.2) # make an example ACF
>>> # Finding the filter coefficients
>>> lin_trans_surface = s.RandomFilterSurface(target_acf=target_acf, grid_spacing=0.01)
>>> lin_trans_surface.linear_transform(filter_shape=(40,20), gtol=1e-5, symmetric=True)
>>> # Setting the skew and kurtosis of the output surface
>>> lin_trans_surface.set_moments(skew = -0.5, kurtosis=5)
>>> # generating and showing a realisation of the surface
>>> my_realisation = lin_trans_surface.discretise([512,512], periodic=False, create_new=True)
>>> fig, axes = my_realisation.show(['profile', 'acf', 'histogram'], ['image', 'image'], figsize=(15,5))
"""
self._method_keywords = {**locals()}
del (self._method_keywords['self'])
self.surface_type = 'linear_transform'
if self.target_acf is None:
raise ValueError("No target ACF given, a target ACF must be given before the filter coefficients can be "
"found")
# n by m ACF
n = filter_shape[0]
m = filter_shape[1]
if max_it is None:
max_it = n * m * 100
if self.grid_spacing is None:
msg = ("Grid spacing is not set assuming grid grid_spacing is 1, the solution is unique for each grid "
"spacing")
warnings.warn(msg)
self.grid_spacing = 1
# generate the acf array form the ACF object
el = self.grid_spacing * np.arange(n)
k = self.grid_spacing * np.arange(m)
acf_array = self.target_acf(k, el)
self.target_acf_array = acf_array
# initial guess (n by m guess of filter coefficients)
x0 = _initial_guess(acf_array)
if symmetric:
result = minimize(_min_fun_symmetric, x0/2, args=(acf_array,), method=method,
jac=_get_grad_min_fun_symmetric, tol=gtol,
**minimize_kwargs)
else:
result = minimize(_min_fun, x0, args=(acf_array,), method=method, jac=_get_grad_min_fun, tol=gtol,
**minimize_kwargs)
if not result.success:
warnings.warn(result.message)
alpha = | np.reshape(result.x, filter_shape) | numpy.reshape |
import numpy as np
from tf.transformations import euler_from_quaternion
from geometry_msgs.msg import PoseStamped, TwistStamped
from utilities import *
class Stanley(object):
def __init__(self, reference_waypoints, wheel_base, max_steering_angle):
self.wheel_base = wheel_base
self.max_steering_angle = max_steering_angle
def step(self, current_pose):
"""
Parameters
----------
current_pose: PoseStamped
the current pose of the ego vehicle
Returns
-------
steering: float
the steering angle in degrees
"""
# Transform coordinates onto front axis
ego_x, ego_y, _ = get_position_from(current_pose)
ego_yaw = get_yaw_from(current_pose)
ego_front_x = ego_x + self.wheel_base * np.cos(ego_yaw)
ego_front_y = ego_y + self.wheel_base * np.sin(ego_yaw)
# TODO: Yaw desired on basis of next waypoint
# TODO: Crosstrack error on basis of next waypoint
# Calculate cross track error
offset = 100
min_dist = float("inf")
min_idx = 0
for i in range(len(waypoints)):
dist = np.linalg.norm(
np.array([waypoints[i][0] - xf, waypoints[i][1] - yf]))
if dist < min_dist:
min_dist = dist
min_idx = i
wp1 = np.array(self._waypoints[min_idx][0:2])
if min_idx < len(self._waypoints) - offset - 1:
wp2 = np.array(self._waypoints[min_idx + offset][0:2])
yaw_desired = np.arctan2(wp2[1] - wp1[1], wp2[0] - wp1[0])
else:
wp2 = | np.array(self._waypoints[-offset][0:2]) | numpy.array |
"""
Utilities to modify a given neural network and obtain a new one.
--<EMAIL>
"""
# pylint: disable=import-error
# pylint: disable=no-member
# pylint: disable=invalid-name
# pylint: disable=relative-import
# pylint: disable=star-args
# pylint: disable=too-many-branches
from argparse import Namespace
from copy import deepcopy
import numpy as np
# Local imports
from ..nn.neural_network import ConvNeuralNetwork, MultiLayerPerceptron, MLP_RECTIFIERS, \
MLP_SIGMOIDS, is_a_pooling_layer_label, is_a_conv_layer_label,\
CNNImageSizeMismatchException, CNNNoConvAfterIPException
from ..utils.general_utils import reorder_list_or_array, reorder_rows_and_cols_in_matrix
from ..utils.option_handler import get_option_specs, load_options
from ..utils.reporters import get_reporter
_DFLT_CHANGE_FRAC = 0.125
_DFLT_CHANGE_NUM_UNITS_SPAWN = 'all'
_DFLT_CHANGE_LAYERS_SPAWN = 20
_DFLT_NUM_SINGLE_STEP_MODIFICATIONS = 'all'
_DFLT_NUM_TWO_STEP_MODIFICATIONS = 0
_DFLT_NUM_THREE_STEP_MODIFICATIONS = 0
_DFLT_WEDGE_LAYER_CNN_CANDIDATES = ['conv3', 'conv5', 'conv7', 'res3', 'res5', 'res7']
_DFLT_WEDGE_LAYER_MLP_CANDIDATES = MLP_RECTIFIERS + MLP_SIGMOIDS
_DFLT_SIGMOID_SWAP = MLP_SIGMOIDS
_DFLT_RECTIFIER_SWAP = MLP_RECTIFIERS
_PRIMITIVE_PROB_MASSES = {'inc_single': 0.1,
'dec_single': 0.1,
'inc_en_masse': 0.1,
'dec_en_masse': 0.1,
'swap_layer': 0.2,
'wedge_layer': 0.1,
'remove_layer': 0.1,
'branch': 0.2,
'skip': 0.2,
}
nn_modifier_args = [
# Change fractions for increasing the number of units in layers.
get_option_specs('single_inc_change_frac', False, _DFLT_CHANGE_FRAC,
'Default change fraction when increasing a single layer.'),
get_option_specs('single_dec_change_frac', False, _DFLT_CHANGE_FRAC,
'Default change fraction when decreasing a single layer.'),
get_option_specs('en_masse_inc_change_frac', False, _DFLT_CHANGE_FRAC,
'Default change fraction when increasing layers en_masse.'),
get_option_specs('en_masse_dec_change_frac', False, _DFLT_CHANGE_FRAC,
'Default change fraction when decreasing layers en_masse.'),
# Number of networks to spawn by changing number of units in a single layer.
get_option_specs('spawn_single_inc_num_units', False, _DFLT_CHANGE_NUM_UNITS_SPAWN,
'Default number of networks to spawn by increasing # units in a single layer.'),
get_option_specs('spawn_single_dec_num_units', False, _DFLT_CHANGE_NUM_UNITS_SPAWN,
'Default number of networks to spawn by decreasing # units in a single layer.'),
# Number of networks to spawn by adding or deleting a single layer.
get_option_specs('spawn_add_layer', False, _DFLT_CHANGE_LAYERS_SPAWN,
'Default number of networks to spawn by adding a layer.'),
get_option_specs('spawn_del_layer', False, _DFLT_CHANGE_LAYERS_SPAWN,
'Default number of networks to spawn by deleting a layer.'),
# Number of double/triple step candidates - i.e. applications of basic primitives
# twice/thrice before executing candidates
get_option_specs('num_single_step_modifications', False,
_DFLT_NUM_SINGLE_STEP_MODIFICATIONS,
'Default number of networks to spawn via single step primitives.'),
get_option_specs('num_two_step_modifications', False,
_DFLT_NUM_TWO_STEP_MODIFICATIONS,
'Default number of networks to spawn via two step primitives.'),
get_option_specs('num_three_step_modifications', False,
_DFLT_NUM_THREE_STEP_MODIFICATIONS,
'Default number of networks to spawn via three step primitives.'),
]
# Generic utilities we will need in all functions below ==================================
def get_copies_from_old_nn(nn):
""" Gets copies of critical parameters of the old network. """
layer_labels = deepcopy(nn.layer_labels)
num_units_in_each_layer = deepcopy(nn.num_units_in_each_layer)
conn_mat = deepcopy(nn.conn_mat)
mandatory_child_attributes = Namespace()
for mca_str in nn.mandatory_child_attributes:
mca_val = deepcopy(getattr(nn, mca_str))
setattr(mandatory_child_attributes, mca_str, mca_val)
return layer_labels, num_units_in_each_layer, conn_mat, mandatory_child_attributes
def get_new_nn(old_nn, layer_labels, num_units_in_each_layer, conn_mat,
mandatory_child_attributes):
""" Returns a new neural network of the same type as old_nn. """
known_nn_class = True
try:
if old_nn.nn_class == 'cnn':
new_cnn = ConvNeuralNetwork(layer_labels, conn_mat, num_units_in_each_layer,
mandatory_child_attributes.strides,
old_nn.all_layer_label_classes,
old_nn.layer_label_similarities)
return new_cnn
elif old_nn.nn_class.startswith('mlp'):
return MultiLayerPerceptron(old_nn.nn_class[4:], layer_labels, conn_mat,
num_units_in_each_layer, old_nn.all_layer_label_classes,
old_nn.layer_label_similarities)
else:
known_nn_class = False
except (CNNImageSizeMismatchException, CNNNoConvAfterIPException, AssertionError):
return None
if not known_nn_class:
raise ValueError('Unidentified nn_class %s.'%(old_nn.nn_class))
def add_layers_to_end_of_conn_mat(conn_mat, num_add_layers):
""" Adds layers with no edges and returns. """
new_num_layers = conn_mat.shape[0] + num_add_layers
conn_mat.resize((new_num_layers, new_num_layers))
return conn_mat
# Change architecture of the network
# ========================================================================================
# Add a layer ----------------------------------------------------------------------------
def wedge_layer(nn, layer_type, units_in_layer, layer_before, layer_after,
new_layer_attributes=None):
""" Wedges a layer of type layer_type after the layer given in layer_before. The
output of the layer in layer_before goes to the new layer and the output of the
new layer goes to layer_after. If an edge existed between layer_before and
layer_after, it is removed. """
layer_labels, num_units_in_each_layer, conn_mat, mandatory_child_attributes = \
get_copies_from_old_nn(nn)
layer_labels.append(layer_type)
num_units_in_each_layer = np.append(num_units_in_each_layer, units_in_layer)
if nn.nn_class == 'cnn':
mandatory_child_attributes.strides.append(new_layer_attributes.stride)
conn_mat = add_layers_to_end_of_conn_mat(conn_mat, 1)
conn_mat[layer_before, -1] = 1
conn_mat[-1, layer_after] = 1
conn_mat[layer_before, layer_after] = 0
return get_new_nn(nn, layer_labels, num_units_in_each_layer, conn_mat,
mandatory_child_attributes)
def _get_non_None_elements(iter_of_vals):
""" Returns non None values. """
return [x for x in iter_of_vals if x is not None]
def _determine_num_units_for_wedge_layer(nn, edge):
""" Determines the number of layers for wedging a layer. This is usually the average
of the parent (edge[0]) and child (edge[1]).
"""
edge_num_layers = _get_non_None_elements(
[nn.num_units_in_each_layer[idx] for idx in edge])
if len(edge_num_layers) > 0:
return round(sum(edge_num_layers) / len(edge_num_layers))
else:
parents = nn.get_parents(edge[0])
if len(parents) == 0:
# Means you have reached the input node
ip_children = nn.get_children(edge[0])
children_num_units = _get_non_None_elements(
[nn.num_units_in_each_layer[ch] for ch in ip_children])
if len(children_num_units) == 0:
# Create a layer with 16 units
children_num_units = [16]
return sum(children_num_units) / len(children_num_units)
else:
parent_num_units = _get_non_None_elements(
[nn.num_units_in_each_layer[par] for par in parents])
if len(parent_num_units) > 0:
return sum(parent_num_units) / len(parent_num_units)
else:
par_num_units = []
for par in parents:
par_num_units.append(_determine_num_units_for_wedge_layer(nn, (par, edge[0])))
par_num_units = _get_non_None_elements(par_num_units)
return sum(par_num_units) / len(par_num_units)
def get_list_of_wedge_layer_modifiers(nn, num_modifications='all',
internal_layer_type_candidates=None,
choose_pool_with_prob=0.05,
choose_stride_2_with_prob=0.05):
""" Returns a list of operations for adding a layer in between two layers. """
# A local function for creating a modifier
def _get_wedge_modifier(_layer_type, _num_units, _edge, _nl_attributes):
""" Returns a modifier which wedges an edge between the edge. """
return lambda arg_nn: wedge_layer(arg_nn, _layer_type, _num_units,
_edge[0], _edge[1], _nl_attributes)
# Pre-process arguments
nn_is_a_cnn = nn.nn_class == 'cnn'
if internal_layer_type_candidates is None:
if nn_is_a_cnn:
internal_layer_type_candidates = _DFLT_WEDGE_LAYER_CNN_CANDIDATES
else:
internal_layer_type_candidates = _DFLT_WEDGE_LAYER_MLP_CANDIDATES
if not nn_is_a_cnn:
choose_pool_with_prob = 0
all_edges = nn.get_edges()
num_modifications = len(all_edges) if num_modifications == 'all' else num_modifications
op_layer_idx = nn.get_op_layer_idx() # Output layer
ip_layer_idx = nn.get_ip_layer_idx() # Input layer
# We won't change this below so keep it as it is
nonconv_nl_attrs = Namespace(stride=None)
conv_nl_attrs_w_stride_1 = Namespace(stride=1)
conv_nl_attrs_w_stride_2 = Namespace(stride=2)
# Iterate through all edges
ret = []
for edge in all_edges:
curr_layer_type = None
# First handle the edges cases
if edge[1] == op_layer_idx:
continue
elif nn_is_a_cnn and nn.layer_labels[edge[0]] == 'fc':
curr_layer_type = 'fc'
curr_num_units = nn.num_units_in_each_layer[edge[0]]
nl_attrs = nonconv_nl_attrs
elif not nn_is_a_cnn and edge[1] == op_layer_idx:
# Don't add new layers just before the output for MLPs
continue
elif edge[0] == ip_layer_idx and nn_is_a_cnn:
curr_pool_prob = 0 # No pooling layer right after the input for a CNN
else:
curr_pool_prob = choose_pool_with_prob
if curr_layer_type is None:
if | np.random.random() | numpy.random.random |
# -*- coding: utf-8 -*-
# vim: tabstop=4 shiftwidth=4 softtabstop=4
#
# LICENSE
#
# Copyright (C) 2010-2018 GEM Foundation, <NAME>, <NAME>,
# <NAME>.
#
# The Hazard Modeller's Toolkit is free software: you can redistribute
# it and/or modify it under the terms of the GNU Affero General Public
# License as published by the Free Software Foundation, either version
# 3 of the License, or (at your option) any later version.
#
# You should have received a copy of the GNU Affero General Public License
# along with OpenQuake. If not, see <http://www.gnu.org/licenses/>
#
# DISCLAIMER
#
# The software Hazard Modeller's Toolkit (openquake.hmtk) provided herein
# is released as a prototype implementation on behalf of
# scientists and engineers working within the GEM Foundation (Global
# Earthquake Model).
#
# It is distributed for the purpose of open collaboration and in the
# hope that it will be useful to the scientific, engineering, disaster
# risk and software design communities.
#
# The software is NOT distributed as part of GEM’s OpenQuake suite
# (https://www.globalquakemodel.org/tools-products) and must be considered as a
# separate entity. The software provided herein is designed and implemented
# by scientific staff. It is not developed to the design standards, nor
# subject to same level of critical review by professional software
# developers, as GEM’s OpenQuake software suite.
#
# Feedback and contribution to the software is welcome, and can be
# directed to the hazard scientific staff of the GEM Model Facility
# (<EMAIL>).
#
# The Hazard Modeller's Toolkit (openquake.hmtk) is therefore distributed WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
# for more details.
#
# The GEM Foundation, and the authors of the software, assume no
# liability for use of the software.
import warnings
import numpy as np
from openquake.hmtk.seismicity.occurrence.base import (
SeismicityOccurrence, OCCURRENCE_METHODS)
from openquake.hmtk.seismicity.occurrence.utils import (input_checks,
get_completeness_counts)
@OCCURRENCE_METHODS.add(
'calculate',
completeness=True,
reference_magnitude=0.0,
magnitude_interval=0.1,
bvalue=1.0,
itstab=1E-5,
maxiter=1000)
class Weichert(SeismicityOccurrence):
'''Class to Implement Weichert Algorithm'''
def calculate(self, catalogue, config, completeness=None):
'''Calculates recurrence using the Weichert (1980) method'''
# Input checks
cmag, ctime, ref_mag, _, config = input_checks(catalogue,
config,
completeness)
if not "dtime" in catalogue.data.keys() or not\
len(catalogue.data["dtime"]):
catalogue.data["dtime"] = catalogue.get_decimal_time()
if not catalogue.end_year:
catalogue.update_end_year()
if completeness is None:
start_year = float(np.min(catalogue.data["year"]))
completeness = np.column_stack([ctime, cmag])
# Apply Weichert preparation
cent_mag, t_per, n_obs = get_completeness_counts(
catalogue, completeness, config["magnitude_interval"])
# A few more Weichert checks
key_list = config.keys()
if (not 'bvalue' in key_list) or (not config['bvalue']):
config['bvalue'] = 1.0
if (not 'itstab' in key_list) or (not config['itstab']):
config['itstab'] = 1E-5
if (not 'maxiter' in key_list) or (not config['maxiter']):
config['maxiter'] = 1000
bval, sigma_b, rate, sigma_rate, aval, sigma_a = \
self.weichert_algorithm(t_per, cent_mag, n_obs, ref_mag,
config['bvalue'], config['itstab'], config['maxiter'])
if not config['reference_magnitude']:
rate = np.log10(aval)
sigma_rate = np.log10(aval + sigma_a) - np.log10(aval)
return bval, sigma_b, rate, sigma_rate
def weichert_algorithm(self, tper, fmag, nobs, mrate=0.0, bval=1.0,
itstab=1E-5, maxiter=1000):
"""
Weichert algorithm
:param tper: length of observation period corresponding to magnitude
:type tper: numpy.ndarray (float)
:param fmag: central magnitude
:type fmag: numpy.ndarray (float)
:param nobs: number of events in magnitude increment
:type nobs: numpy.ndarray (int)
:keyword mrate: reference magnitude
:type mrate: float
:keyword bval: initial value for b-value
:type beta: float
:keyword itstab: stabilisation tolerance
:type itstab: float
:keyword maxiter: Maximum number of iterations
:type maxiter: Int
:returns: b-value, sigma_b, a-value, sigma_a
:rtype: float
"""
beta = bval * | np.log(10.) | numpy.log |
# -*- coding: utf-8 -*-
#
# License: This module is released under the terms of the LICENSE file
# contained within this applications INSTALL directory
"""
Defines the ForecastModel class, which encapsulates model functions used in
forecast model fitting, as well as their number of parameters and
initialisation parameters.
"""
# -- Coding Conventions
# http://www.python.org/dev/peps/pep-0008/ - Use the Python style guide
# http://sphinx.pocoo.org/rest.html - Use Restructured Text for
# docstrings
# -- Public Imports
import itertools
import logging
import numpy as np
import pandas as pd
from pandas.tseries.holiday import Holiday, AbstractHolidayCalendar, \
MO, nearest_workday, next_monday, next_monday_or_tuesday, \
GoodFriday, EasterMonday, USFederalHolidayCalendar
from pandas.tseries.offsets import DateOffset
from datetime import datetime
# -- Private Imports
from anticipy import model_utils
# -- Globals
logger = logging.getLogger(__name__)
# Fourier model configuration
_dict_fourier_config = { # Default configuration for fourier-based models
'period': 365.25, # days in year
'harmonics': 10 # TODO: evaluate different harmonics values
}
_FOURIER_PERIOD = 365.25
_FOURIER_HARMONICS = 10 # TODO: evaluate different harmonics values
_FOURIER_K = (2.0 * np.pi / _FOURIER_PERIOD)
_FOURIER_I = np.arange(1, _FOURIER_HARMONICS + 1)
_FOURIER_DATE_ORIGIN = datetime(1970, 1, 1)
# -- Functions
# ---- Utility functions
def logger_info(msg, data):
# Convenience function for easier log typing
logger.info(msg + '\n%s', data)
def _get_f_init_params_default(n_params):
# Generate a default function for initialising model parameters: use
# random values between 0 and 1
return lambda a_x=None, a_y=None, a_date=None, is_mult=False:\
np.random.uniform(low=0.001, high=1, size=n_params)
def _get_f_bounds_default(n_params):
# Generate a default function for model parameter boundaries. Default
# boundaries are (-inf, inf)
return lambda a_x=None, a_y=None, a_date=None: (
n_params * [-np.inf], n_params * [np.inf])
def _get_f_add_2_f_models(forecast_model1, forecast_model2):
# Add model functions of 2 ForecastModels
def f_add_2_f_models(a_x, a_date, params, is_mult=False, **kwargs):
params1 = params[0:forecast_model1.n_params]
params2 = params[forecast_model1.n_params:]
return (
forecast_model1.f_model(
a_x,
a_date,
params1,
is_mult=False,
**kwargs) +
forecast_model2.f_model(
a_x,
a_date,
params2,
is_mult=False,
**kwargs))
return f_add_2_f_models
def _get_f_mult_2_f_models(forecast_model1, forecast_model2):
# Multiply model functions of 2 ForecastModels
def f_mult_2_f_models(a_x, a_date, params, is_mult=False, **kwargs):
params1 = params[0:forecast_model1.n_params]
params2 = params[forecast_model1.n_params:]
return (
forecast_model1.f_model(
a_x,
a_date,
params1,
is_mult=True,
**kwargs) *
forecast_model2.f_model(
a_x,
a_date,
params2,
is_mult=True,
**kwargs))
return f_mult_2_f_models
def _get_f_add_2_f_init_params(f_init_params1, f_init_params2):
# Compose parameter initialisation functions of 2 ForecastModels, using
# addition
def f_add_2_f_init_params(a_x, a_y, a_date=None, is_mult=False):
return np.concatenate(
[f_init_params1(a_x, a_y, a_date, is_mult=False),
f_init_params2(a_x, a_y, a_date, is_mult=False)])
return f_add_2_f_init_params
def _get_f_mult_2_f_init_params(f_init_params1, f_init_params2):
# Compose parameter initialisation functions of 2 ForecastModels, using
# multiplication
def f_mult_2_f_init_params(a_x, a_y, a_date=None, is_mult=False):
return np.concatenate(
[f_init_params1(a_x, a_y, a_date, is_mult=True),
f_init_params2(a_x, a_y, a_date, is_mult=True)])
return f_mult_2_f_init_params
def _get_f_concat_2_bounds(forecast_model1, forecast_model2):
# Compose parameter boundary functions of 2 ForecastModels
def f_add_2_f_bounds(a_x, a_y, a_date=None):
return np.concatenate(
(forecast_model1.f_bounds(
a_x, a_y, a_date), forecast_model2.f_bounds(
a_x, a_y, a_date)), axis=1)
return f_add_2_f_bounds
def _f_validate_input_default(a_x, a_y, a_date):
# Default input validation function for a ForecastModel. Always returns
# True
return True
def _as_list(l):
return l if isinstance(l, (list,)) else [l]
# Functions used to initialize cache variables in a ForecastModel
def _f_init_cache_a_month(a_x, a_date):
return a_date.month - 1
def _f_init_cache_a_weekday(a_x, a_date):
return a_date.weekday
def _f_init_cache_a_t_fourier(a_x, a_date):
# convert to days since epoch
t = (a_date - _FOURIER_DATE_ORIGIN).days.values
i = np.arange(1, _FOURIER_HARMONICS + 1)
a_tmp = _FOURIER_K * i.reshape(i.size, 1) * t
y = np.concatenate([np.sin(a_tmp), np.cos(a_tmp)])
return y
# Dictionary to store functions used to initialize cache variables
# in a ForecastModel
# This is shared across all ForecastModel instances
_dict_f_cache = dict(
a_month=_f_init_cache_a_month,
a_weekday=_f_init_cache_a_weekday,
a_t_fourier=_f_init_cache_a_t_fourier
)
# -- Classes
class ForecastModel:
"""
Class that encapsulates model functions for use in forecasting, as well as
their number of parameters and functions for parameter initialisation.
A ForecastModel instance is initialized with a model name, a number of
model parameters, and a model function. Class instances are
callable - when called as a function, their internal model function is
used. The main purpose of ForecastModel objects is to generate predicted
values for a time series, given a set of parameters. These values can be
compared to the original series to get an array of residuals::
y_predicted = model(a_x, a_date, params)
residuals = (a_y - y_predicted)
This is used in an optimization loop to obtain the optimal parameters for
the model.
The reason for using this class instead of raw model functions is that
ForecastModel supports function composition::
model_sum = fcast_model1 + fcast_model2
# fcast_model 1 and 2 are ForecastModel instances, and so is model_sum
a_y1 = fcast_model1(
a_x, a_date, params1) + fcast_model2(a_x, a_date, params2)
params = np.concatenate([params1, params2])
a_y2 = model_sum(a_x, a_date, params)
a_y1 == a_y2 # True
Forecast models can be added or multiplied, with the + and * operators.
Multiple levels of composition are supported::
model = (model1 + model2) * model3
Model composition is used to aggregate trend and seasonality model
components, among other uses.
Model functions have the following signature:
- f(a_x, a_date, params, is_mult)
- a_x : array of floats
- a_date: array of dates, same length as a_x. Only required for date-aware
models, e.g. for weekly seasonality.
- params: array of floats - model parameters - the optimisation loop
updates this to fit our actual values. Each
model function uses a fixed number of parameters.
- is_mult: boolean. True if the model is being used with multiplicative
composition. Required because
some model functions (e.g. steps) have different behaviour
when added to other models than when multiplying them.
- returns an array of floats - with same length as a_x - output of the
model defined by this object's modelling function f_model and the
current set of parameters
By default, model parameters are initialized as random values between
0 and 1. It is possible to define a parameter initialization function
that picks initial values based on the original time series.
This is passed during ForecastModel creation with the argument
f_init_params. Parameter initialization is compatible with model
composition: the initialization function of each component will be used
for that component's parameters.
Parameter initialisation functions have the following signature:
- f_init_params(a_x, a_y, is_mult)
- a_x: array of floats - same length as time series
- a_y: array of floats - time series values
- returns an array of floats - with length equal to this object's n_params
value
By default, model parameters have no boundaries. However, it is possible
to define a boundary function for a model, that sets boundaries for each
model parameter, based on the input time series. This is passed during
ForecastModel creation with the argument f_bounds.
Boundary definition is compatible with model composition:
the boundary function of each component will be used for that component's
parameters.
Boundary functions have the following signature:
- f_bounds(a_x, a_y, a_date)
- a_x: array of floats - same length as time series
- a_y: array of floats - time series values
- a_date: array of dates, same length as a_x. Only required for date-aware
models, e.g. for weekly seasonality.
- returns a tuple of 2 arrays of floats. The first defines minimum
parameter boundaries, and the second the maximum parameter boundaries.
As an option, we can assign a list of input validation functions to a
model. These functions analyse the inputs that will be used for fitting a
model, returning True if valid, and False otherwise. The forecast logic
will skip a model from fitting if any of the validation functions for that
model returns False.
Input validation functions have the following signature:
- f_validate_input(a_x, a_y, a_date)
- See the description of model functions above for more details on these
parameters.
Our input time series should meet the following constraints:
- Minimum required samples depends on number of model parameters
- May include null values
- May include multiple values per sample
- A date array is only required if the model is date-aware
Class Usage::
model_x = ForecastModel(name, n_params, f_model, f_init_params,
l_f_validate_input)
# Get model name
model_name = model_x.name
# Get number of model parameters
n_params = model_x.n_params
# Get parameter initialisation function
f_init_params = model_x.f_init_params
# Get initial parameters
init_params = f_init_params(t_values, y_values)
# Get model fitting function
f_model = model_x.f_model
# Get model output
y = f_model(a_x, a_date, parameters)
The following pre-generated models are available. They are available as attributes from this module: # noqa
.. csv-table:: Forecast models
:header: "name", "params", "formula","notes"
:widths: 20, 10, 20, 40
"model_null",0, "y=0", "Does nothing.
Used to disable components (e.g. seasonality)"
"model_constant",1, "y=A", "Constant model"
"model_linear",2, "y=Ax + B", "Linear model"
"model_linear_nondec",2, "y=Ax + B", "Non decreasing linear model.
With boundaries to ensure model slope >=0"
"model_quasilinear",3, "y=A*(x^B) + C", "Quasilinear model"
"model_exp",2, "y=A * B^x", "Exponential model"
"model_decay",4, "Y = A * e^(B*(x-C)) + D", "Exponential decay model"
"model_step",2, "y=0 if x<A, y=B if x>=A", "Step model"
"model_two_steps",4, "see model_step", "2 step models.
Parameter initialization is aware of # of steps."
"model_sigmoid_step",3, "y = A + (B - A) / (1 + np.exp(- D * (x - C)))
", "Sigmoid step model"
"model_sigmoid",3, "y = A + (B - A) / (1 + np.exp(- D * (x - C)))", "
Sigmoid model"
"model_season_wday",7, "see desc.", "Weekday seasonality model.
Assigns a constant value to each weekday"
"model_season_wday",6, "see desc.", "6-param weekday seasonality model.
As above, with one constant set to 0."
"model_season_wday_2",2, "see desc.", "Weekend seasonality model.
Assigns a constant to each of weekday/weekend"
"model_season_month",12, "see desc.", "Month seasonality model.
Assigns a constant value to each month"
"model_season_fourier_yearly",10, "see desc", "Fourier
yearly seasonality model"
"""
def __init__(
self,
name,
n_params,
f_model,
f_init_params=None,
f_bounds=None,
l_f_validate_input=None,
l_cache_vars=None,
dict_f_cache=None,
):
"""
Create ForecastModel
:param name: Model name
:type name: basestring
:param n_params: Number of parameters for model function
:type n_params: int
:param f_model: Model function
:type f_model: function
:param f_init_params: Parameter initialisation function
:type f_init_params: function
:param f_bounds: Boundary function
:type f_bounds: function
"""
self.name = name
self.n_params = n_params
self.f_model = f_model
if f_init_params is not None:
self.f_init_params = f_init_params
else:
# Default initial parameters: random values between 0 and 1
self.f_init_params = _get_f_init_params_default(n_params)
if f_bounds is not None:
self.f_bounds = f_bounds
else:
self.f_bounds = _get_f_bounds_default(n_params)
if l_f_validate_input is None:
self.l_f_validate_input = [_f_validate_input_default]
else:
self.l_f_validate_input = _as_list(l_f_validate_input)
if l_cache_vars is None:
self.l_cache_vars = []
else:
self.l_cache_vars = _as_list(l_cache_vars)
if dict_f_cache is None:
self.dict_f_cache = dict()
else:
self.dict_f_cache = dict_f_cache
# TODO - REMOVE THIS - ASSUME NORMALIZED INPUT
def _get_f_init_params_validated(f_init_params):
# Adds argument validation to a parameter initialisation function
def f_init_params_validated(
a_x=None, a_y=None, a_date=None, is_mult=False):
if a_x is not None and pd.isnull(a_x).any():
raise ValueError('a_x cannot have null values')
return f_init_params(a_x, a_y, a_date, is_mult)
return f_init_params_validated
# Add logic to f_init_params that validates input
self.f_init_params = _get_f_init_params_validated(self.f_init_params)
def __call__(self, a_x, a_date, params, is_mult=False, **kwargs):
# assert len(params)==self.n_params
return self.f_model(a_x, a_date, params, is_mult, **kwargs)
def __str__(self):
return self.name
def __repr__(self):
return 'ForecastModel:{}'.format(self.name)
def __add__(self, forecast_model):
# Check for nulls
if self.name == 'null':
return forecast_model
if forecast_model.name == 'null':
return self
name = '({}+{})'.format(self.name, forecast_model.name)
n_params = self.n_params + forecast_model.n_params
f_model = _get_f_add_2_f_models(self, forecast_model)
f_init_params = _get_f_add_2_f_init_params(
self.f_init_params, forecast_model.f_init_params)
f_bounds = _get_f_concat_2_bounds(self, forecast_model)
l_f_validate_input = list(
set(self.l_f_validate_input + forecast_model.l_f_validate_input))
# Combine both dicts
dict_f_cache = self.dict_f_cache.copy()
dict_f_cache.update(forecast_model.dict_f_cache)
l_cache_vars = list(
set(self.l_cache_vars + forecast_model.l_cache_vars))
return ForecastModel(
name,
n_params,
f_model,
f_init_params,
f_bounds=f_bounds,
l_f_validate_input=l_f_validate_input,
l_cache_vars=l_cache_vars,
dict_f_cache=dict_f_cache
)
def __radd__(self, other):
return self.__add__(other)
def __mul__(self, forecast_model):
if self.name == 'null':
return forecast_model
if forecast_model.name == 'null':
return self
name = '({}*{})'.format(self.name, forecast_model.name)
n_params = self.n_params + forecast_model.n_params
f_model = _get_f_mult_2_f_models(self, forecast_model)
f_init_params = _get_f_mult_2_f_init_params(
self.f_init_params, forecast_model.f_init_params)
f_bounds = _get_f_concat_2_bounds(self, forecast_model)
l_f_validate_input = list(
set(self.l_f_validate_input + forecast_model.l_f_validate_input))
# Combine both dicts
dict_f_cache = self.dict_f_cache.copy()
dict_f_cache.update(forecast_model.dict_f_cache)
l_cache_vars = list(
set(self.l_cache_vars + forecast_model.l_cache_vars))
return ForecastModel(
name,
n_params,
f_model,
f_init_params,
f_bounds=f_bounds,
l_f_validate_input=l_f_validate_input,
l_cache_vars=l_cache_vars,
dict_f_cache=dict_f_cache
)
def __rmul__(self, other):
return self.__mul__(other)
def __eq__(self, other):
if isinstance(self, other.__class__):
return self.name == other.name
return NotImplemented
def __ne__(self, other):
x = self.__eq__(other)
if x is not NotImplemented:
return not x
return NotImplemented
def __hash__(self):
return hash(self.name)
def __lt__(self, other):
return self.name < other.name
def validate_input(self, a_x, a_y, a_date):
try:
l_result = [f_validate_input(a_x, a_y, a_date)
for f_validate_input in self.l_f_validate_input]
except AssertionError:
return False
return True
def init_cache(self, a_x, a_date):
dict_cache_vars = dict()
for k in self.l_cache_vars:
f = _dict_f_cache.get(k)
if f:
dict_cache_vars[k] = f(a_x, a_date)
else:
logger.warning('Cache function not found: %s', k)
# Search vars defined in internal cache function dictionary
for k in self.dict_f_cache:
f = self.dict_f_cache.get(k)
if f:
dict_cache_vars[k] = f(a_x, a_date)
else:
logger.warning('Cache function not found: %s', k)
return dict_cache_vars
# - Null model: 0
def _f_model_null(a_x, a_date, params, is_mult=False, **kwargs):
# This model does nothing - used to disable model components
# (e.g. seasonality) when adding/multiplying multiple functions
return float(is_mult) # Returns 1 if multiplying, 0 if adding
model_null = ForecastModel('null', 0, _f_model_null)
# - Constant model: :math:`Y = A`
def _f_model_constant(a_x, a_date, params, is_mult=False, **kwargs):
[A] = params
y = np.full(len(a_x), A)
return y
def _f_init_params_constant(a_x=None, a_y=None, a_date=None, is_mult=False):
if a_y is None:
return np.random.uniform(0, 1, 1)
else:
return np.nanmean(a_y) + np.random.uniform(0, 1, 1)
model_constant = ForecastModel(
'constant',
1,
_f_model_constant,
_f_init_params_constant)
# - Naive model: Y = Y(x-1)
# Note: This model requires passing the actuals data - it is not fitted by
# regression. We still pass it to forecast.fit_model() for consistency
# with the rest of the library
def _f_model_naive(a_x, a_date, params, is_mult=False, df_actuals=None):
if df_actuals is None:
raise ValueError('model_naive requires a df_actuals argument')
df_out_tmp = pd.DataFrame({'date': a_date, 'x': a_x})
df_out = (
# This is not really intended to work with multiple values per sample
df_actuals.drop_duplicates('x')
.merge(df_out_tmp, how='outer')
.sort_values('x')
)
df_out['y'] = (
df_out.y.shift(1)
.fillna(method='ffill')
.fillna(method='bfill')
)
df_out = df_out.loc[df_out.x.isin(a_x)]
# df_out = df_out_tmp.merge(df_out, how='left')
# TODO: CHECK THAT X,DATE order is preserved
# TODO: df_out = df_out.merge(df_out_tmp, how='right')
return df_out.y.values
model_naive = ForecastModel('naive', 0, _f_model_naive)
# - Seasonal naive model
# Note: This model requires passing the actuals data - it is not fitted by
# regression. We still pass it to forecast.fit_model() for consistency
# with the rest of the library
def _fillna_wday(df):
"""
In a time series, shift samples by 1 week
and fill gaps with data from same weekday
"""
def add_col_y_out(df):
df = df.assign(y_out=df.y.shift(1).fillna(method='ffill'))
return df
df_out = (
df
.assign(wday=df.date.dt.weekday)
.groupby('wday', as_index=False).apply(add_col_y_out)
.sort_values(['x'])
.reset_index(drop=True)
)
return df_out
def _f_model_snaive_wday(a_x, a_date, params, is_mult=False, df_actuals=None):
"""Naive model - takes last valid weekly sample"""
if df_actuals is None:
raise ValueError('model_snaive_wday requires a df_actuals argument')
# df_actuals_model - table with actuals samples,
# adding y_out column with naive model values
df_actuals_model = _fillna_wday(df_actuals.drop_duplicates('x'))
# df_last_week - table with naive model values from last actuals week,
# to use in extrapolation
df_last_week = (
df_actuals_model
# Fill null actual values with data from previous weeks
.assign(y=df_actuals_model.y.fillna(df_actuals_model.y_out))
.drop_duplicates('wday', keep='last')
[['wday', 'y']]
.rename(columns=dict(y='y_out'))
)
# Generate table with extrapolated samples
df_out_tmp = pd.DataFrame({'date': a_date, 'x': a_x})
df_out_tmp['wday'] = df_out_tmp.date.dt.weekday
df_out_extrapolated = (
df_out_tmp
.loc[~df_out_tmp.date.isin(df_actuals_model.date)]
.merge(df_last_week, how='left')
.sort_values('x')
)
# Filter actuals table - only samples in a_x, a_date
df_out_actuals_filtered = (
# df_actuals_model.loc[df_actuals_model.x.isin(a_x)]
# Using merge rather than simple filtering to account for
# dates with multiple samples
df_actuals_model.merge(df_out_tmp, how='inner')
.sort_values('x')
)
df_out = (
pd.concat(
[df_out_actuals_filtered, df_out_extrapolated],
sort=False, ignore_index=True)
)
return df_out.y_out.values
model_snaive_wday = ForecastModel('snaive_wday', 0, _f_model_snaive_wday)
# - Spike model: :math:`Y = A`, when x_min <= X < x_max
def _f_model_spike(a_x, a_date, params, is_mult=False, **kwargs):
[A, x_min, x_max] = params
if is_mult:
c = 1
else:
c = 0
y = np.concatenate((
np.full(int(x_min), c),
np.full(int(x_max - x_min), A),
np.full(len(a_x) - int(x_max), c)
))
return y
def _f_init_params_spike(a_x=None, a_y=None, a_date=None, is_mult=False):
""" params are spike height, x start, x end """
# if not a_y.any():
if a_y is None:
return [1] + np.random.uniform(0, 1, 1) + [2]
else:
diffs = np.diff(a_y)
# if diffs:
if True:
diff = max(diffs)
x_start = np.argmax(diffs)
x_end = x_start + 1
return np.array([diff, x_start, x_end])
model_spike = ForecastModel('spike', 3, _f_model_spike, _f_init_params_spike)
# - Spike model for dates - dates are fixed for each model
def _f_model_spike_date(
a_x,
a_date,
params,
date_start,
date_end,
is_mult=False):
[A] = params
mask_spike = (a_date >= date_start) * (a_date < date_end)
if is_mult:
y = mask_spike * A + ~mask_spike
else:
y = mask_spike * A
return y
def _f_init_params_spike(a_x=None, a_y=None, a_date=None, is_mult=False):
""" params are spike height, x start, x end """
if a_y is None:
return np.concatenate([np.array([1]) + np.random.uniform(0, 1, 1)])
else:
diffs = np.diff(a_y)
# if diffs:
if True:
diff = max(diffs)
return np.array([diff])
# else:
# rand = np.random.randint(1, len(a_y) - 1)
# return [1]
def get_model_spike_date(date_start, date_end):
f_model = (
lambda a_x, a_date, params, is_mult=False, **kwargs:
_f_model_spike_date(a_x, a_date, params, date_start, date_end, is_mult)
)
model_spike_date = ForecastModel(
'spike_date[{},{}]'.format(
pd.to_datetime(date_start).date(),
pd.to_datetime(date_end).date()),
1,
f_model,
_f_init_params_spike)
return model_spike_date
# - Linear model: :math:`Y = A*x + B`
def _f_model_linear(a_x, a_date, params, is_mult=False, **kwargs):
(A, B) = params
y = A * a_x + B
return y
def _f_init_params_linear(a_x=None, a_y=None, a_date=None, is_mult=False):
if a_y is None:
return np.random.uniform(low=0, high=1, size=2)
else: # TODO: Improve this
if a_x is not None:
a_x_size = np.unique(a_x).size - 1
else:
a_x_size = a_y.size - 1
A = (a_y[-1] - a_y[0]) / a_x_size
B = a_y[0]
# Uniform low= 0*m, high = 1*m
return np.array([A, B])
model_linear = ForecastModel(
'linear',
2,
_f_model_linear,
_f_init_params_linear)
def f_init_params_linear_nondec(
a_x=None,
a_y=None,
a_date=None,
is_mult=False):
params = _f_init_params_linear(a_x, a_y, a_date)
if params[0] < 0:
params[0] = 0
return params
def f_bounds_linear_nondec(a_x=None, a_y=None, a_date=None):
# first param should be between 0 and inf
return [0, -np.inf], [np.inf, np.inf]
model_linear_nondec = ForecastModel('linear_nondec', 2, _f_model_linear,
f_init_params=f_init_params_linear_nondec,
f_bounds=f_bounds_linear_nondec)
# - QuasiLinear model: :math:`Y = A t^{B} + C`
def _f_model_quasilinear(a_x, a_date, params, is_mult=False, **kwargs):
(A, B, C) = params
y = A * np.power(a_x, B) + C
return y
model_quasilinear = ForecastModel('quasilinear', 3, _f_model_quasilinear)
# - Exponential model: math:: Y = A * B^t
# TODO: Deprecate - not safe to use
def _f_model_exp(a_x, a_date, params, is_mult=False, **kwargs):
(A, B) = params
y = A * np.power(B, a_x)
return y
model_exp = ForecastModel('exponential', 2, _f_model_exp)
# - Exponential decay model: math:: Y = A * e^(B*(x-C)) + D
def _f_model_decay(a_x, a_date, params, is_mult=False, **kwargs):
(A, B, D) = params
y = A * np.exp(B * (a_x)) + D
return y
def _f_validate_input_decay(a_x, a_y, a_date):
assert (a_y > 0).all()
def f_init_params_decay(a_x=None, a_y=None, a_date=None, is_mult=False):
if a_y is None:
return np.array([0, 0, 0])
A = a_y[0] - a_y[-1]
B = np.log(np.min(a_y) / np.max(a_y)) / (len(a_y) - 1)
if B > 0 or B == -np.inf:
B = -0.5
C = a_y[-1]
return np.array([A, B, C])
def f_bounds_decay(a_x=None, a_y=None, a_date=None):
return [-np.inf, -np.inf, -np.inf], [np.inf, 0, np.inf]
model_decay = ForecastModel('decay', 3, _f_model_decay,
f_init_params=f_init_params_decay,
f_bounds=f_bounds_decay,
l_f_validate_input=_f_validate_input_decay)
# - Step function: :math:`Y = {0, if x < A | B, if x >= A}`
# A is the time of step, and B is the step
def _f_step(a_x, a_date, params, is_mult=False, **kwargs):
(A, B) = params
if is_mult:
y = 1 + (B - 1) * np.heaviside(a_x - A, 1)
else:
y = B * np.heaviside(a_x - A, 1)
return y
# TODO: Implement initialisation for multiplicative composition
def _f_init_params_step(a_x=None, a_y=None, a_date=None, is_mult=False):
if a_y is None:
return np.random.uniform(0, 1, 2)
else:
if a_y.ndim > 1:
a_y = a_y[:, 0]
df = pd.DataFrame({'b': a_y})
# max difference between consecutive values
df['diff'] = df.diff().abs()
# if is_mult, replace above line with something like
# np.concatenate([[np.NaN],a_y[:-1]/a_y[1:]])
a = df.nlargest(1, 'diff').index[0]
b = df['diff'].iloc[a]
return np.array([a, b * 2])
# TODO: Add boundaries for X axis
model_step = ForecastModel('step', 2, _f_step, _f_init_params_step)
# - Spike model for dates - dates are fixed for each model
def _f_model_step_date(a_x, a_date, params, date_start, is_mult=False):
[A] = params
mask_step = (a_date >= date_start).astype(float)
if is_mult:
# y = mask_step*A + ~mask_step
y = mask_step * (A - 1) + 1
else:
y = mask_step * A
return y
# TODO: Implement initialisation for multiplicative composition
def _f_init_params_step_date(a_x=None, a_y=None, a_date=None, is_mult=False):
if a_y is None:
return np.random.uniform(0, 1, 1)
else:
if a_y.ndim > 1:
a_y = a_y[:, 0]
df = pd.DataFrame({'b': a_y})
# max difference between consecutive values
df['diff'] = df.diff().abs()
# if is_mult, replace above line with something like
# np.concatenate([[np.NaN],a_y[:-1]/a_y[1:]])
a = df.nlargest(1, 'diff').index[0]
b = df['diff'].iloc[a]
return np.array([b * 2])
def get_model_step_date(date_start):
date_start = pd.to_datetime(date_start)
f_model = (
lambda a_x, a_date, params, is_mult=False, **kwargs:
_f_model_step_date(a_x, a_date, params, date_start, is_mult)
)
model_step_date = ForecastModel('step_date[{}]'.format(date_start.date()),
1, f_model, _f_init_params_step_date)
return model_step_date
# Two step functions
def _f_n_steps(n, a_x, a_date, params, is_mult=False):
if is_mult:
y = 1
else:
y = 0
for i in range(0, n + 1, 2):
A, B = params[i: i + 2]
if is_mult:
y = y * _f_step(a_x, a_date, (A, B), is_mult)
else:
y = y + _f_step(a_x, a_date, (A, B), is_mult)
return y
def _f_two_steps(a_x, a_date, params, is_mult=False, **kwargs):
return _f_n_steps(
n=2,
a_x=a_x,
a_date=a_date,
params=params,
is_mult=is_mult)
def _f_init_params_n_steps(
n=2,
a_x=None,
a_y=None,
a_date=None,
is_mult=False):
if a_y is None:
return np.random.uniform(0, 1, n * 2)
else:
# max difference between consecutive values
if a_y.ndim > 1:
a_y = a_y[:, 0]
df = pd.DataFrame({'b': a_y})
df['diff'] = df.diff().abs()
# if is_mult, replace above line with something like
# np.concatenate([[np.NaN],a_y[:-1]/a_y[1:]])
a = df.nlargest(n, 'diff').index[0:n].values
b = df['diff'].iloc[a].values
params = []
for i in range(0, n):
params += [a[i], b[i]]
return np.array(params)
def _f_init_params_two_steps(a_x=None, a_y=None, a_date=None, is_mult=False):
return _f_init_params_n_steps(
n=2,
a_x=a_x,
a_y=a_y,
a_date=a_date,
is_mult=is_mult)
model_two_steps = ForecastModel(
'two_steps',
2 * 2,
_f_two_steps,
_f_init_params_two_steps)
# - Sigmoid step function: `Y = {A + (B - A) / (1 + np.exp(- D * (a_x - C)))}`
# Spans from A to B, C is the position of the step in x axis
# and D is how steep the increase is
def _f_sigmoid(a_x, a_date, params, is_mult=False, **kwargs):
(B, C, D) = params
if is_mult:
A = 1
else:
A = 0
# TODO check if a_x is negative
y = A + (B - A) / (1 + np.exp(- D * (a_x - C)))
return y
def _f_init_params_sigmoid_step(
a_x=None,
a_y=None,
a_date=None,
is_mult=False):
if a_y is None:
return np.random.uniform(0, 1, 3)
else:
if a_y.ndim > 1:
a_y = a_y[:, 0]
df = pd.DataFrame({'y': a_y})
# max difference between consecutive values
df['diff'] = df.diff().abs()
c = df.nlargest(1, 'diff').index[0]
b = df.loc[c, 'y']
d = b * b
return b, c, d
def _f_init_bounds_sigmoid_step(a_x=None, a_y=None, a_date=None):
if a_y is None:
return [-np.inf, -np.inf, 0.], 3 * [np.inf]
if a_y.ndim > 1:
a_y = a_y[:, 0]
if a_x.ndim > 1:
a_x = a_x[:, 0]
diff = max(a_y) - min(a_y)
b_min = -2 * diff
b_max = 2 * diff
c_min = min(a_x)
c_max = max(a_x)
d_min = 0.
d_max = np.inf
return [b_min, c_min, d_min], [b_max, c_max, d_max]
# In this model, parameter initialization is aware of number of steps
model_sigmoid_step = ForecastModel(
'sigmoid_step',
3,
_f_sigmoid,
_f_init_params_sigmoid_step,
f_bounds=_f_init_bounds_sigmoid_step)
model_sigmoid = ForecastModel('sigmoid', 3, _f_sigmoid)
# Ramp functions - used for piecewise linear models
# example : model_linear_pw2 = model_linear + model_ramp
# example 2: model_linear_p23 = model_linear + model_ramp + model_ramp
# - Ramp function: :math:`Y = {0, if x < A | B, if x >= A}`
# A is the time of step, and B is the step
def _f_ramp(a_x, a_date, params, is_mult=False, **kwargs):
(A, B) = params
if is_mult:
y = 1 + (a_x - A) * (B) * np.heaviside(a_x - A, 1)
else:
y = (a_x - A) * B * np.heaviside(a_x - A, 1)
return y
def _f_init_params_ramp(a_x=None, a_y=None, a_date=None, is_mult=False):
# TODO: set boundaries: a_x (0.2, 0.8)
if a_y is None:
if a_x is not None:
nfirst_last = int(np.ceil(0.15 * a_x.size))
a = np.random.uniform(a_x[nfirst_last], a_x[-nfirst_last - 1], 1)
else:
a = np.random.uniform(0, 1, 1)
b = np.random.uniform(0, 1, 1)
return np.concatenate([a,
b])
else:
# TODO: FILTER A_Y BY 20-80 PERCENTILE IN A_X
df = pd.DataFrame({'b': a_y})
if a_x is not None:
#
df['x'] = a_x
# Required because we support input with multiple samples per x
# value
df = df.drop_duplicates('x')
df = df.set_index('x')
# max difference between consecutive values -- this assumes no null
# values in series
df['diff2'] = df.diff().diff().abs()
# We ignore the last 15% of the time series
skip_samples = int(np.ceil(df.index.size * 0.15))
a = (df.head(-skip_samples).tail(
-skip_samples).nlargest(1, 'diff2').index[0]
)
b = df['diff2'].loc[a]
# TODO: replace b with estimation of slope in segment 2
# minus slope in segment 1 - see init_params_linear
return np.array([a, b])
def _f_init_bounds_ramp(a_x=None, a_y=None, a_date=None):
if a_x is None:
a_min = -np.inf
a_max = np.inf
else:
# a_min = np.min(a_x)
nfirst_last = int(np.ceil(0.15 * a_x.size))
a_min = a_x[nfirst_last]
a_max = a_x[-nfirst_last]
# a_min = np.percentile(a_x, 15)
# a_max = np.percentile(a_x,85)
if a_y is None:
b_min = -np.inf
b_max = np.inf
else:
# TODO: FILTER A_Y BY 20-80 PERCENTILE IN A_X
# df = pd.DataFrame({'b': a_y})
# #max_diff2 = np.max(df.diff().diff().abs())
# max_diff2 = np.max(np.abs(np.diff(np.diff(a_y))))
#
# b_min = -2*max_diff2
# b_max = 2*max_diff2
b_min = -np.inf
b_max = np.inf
# logger_info('DEBUG: BOUNDS:',(a_min, b_min,a_max, b_max))
return ([a_min, b_min], [a_max, b_max])
model_ramp = ForecastModel(
'ramp',
2,
_f_ramp,
_f_init_params_ramp,
_f_init_bounds_ramp)
# - Weekday seasonality
def _f_model_season_wday(
a_x, a_date, params, is_mult=False,
# cache variables
a_weekday=None,
**kwargs):
# Weekday seasonality model, 6 params
# params_long[0] is default series value,
params_long = np.concatenate([[float(is_mult)], params])
if a_weekday is None:
a_weekday = _f_init_cache_a_weekday(a_x, a_date)
return params_long[a_weekday]
def _f_validate_input_season_wday(a_x, a_y, a_date):
assert a_date is not None
assert a_date.weekday.drop_duplicates().size == 7
model_season_wday = ForecastModel(
'season_wday',
6,
_f_model_season_wday,
l_f_validate_input=_f_validate_input_season_wday,
l_cache_vars=['a_weekday']
)
# - Month seasonality
def _f_init_params_season_month(
a_x=None,
a_y=None,
a_date=None,
is_mult=False):
if a_y is None or a_date is None:
return np.random.uniform(low=-1, high=1, size=11)
else: # TODO: Improve this
l_params_long = [np.mean(a_y[a_date.month == i])
for i in np.arange(1, 13)]
l_baseline = l_params_long[-1]
l_params = l_params_long[:-1]
if not is_mult:
l_params_add = l_params - l_baseline
return l_params_add
else:
l_params_mult = l_params / l_baseline
return l_params_mult
def _f_model_season_month(
a_x, a_date, params, is_mult=False,
# cache variables
a_month=None,
**kwargs):
# Month of December is taken as default level, has no parameter
# params_long[0] is default series value
params_long = np.concatenate([[float(is_mult)], params])
if a_month is None:
a_month = _f_init_cache_a_month(a_x, a_date)
return params_long[a_month]
model_season_month = ForecastModel(
'season_month',
11,
_f_model_season_month,
_f_init_params_season_month,
l_cache_vars=['a_month']
)
model_season_month_old = ForecastModel(
'season_month_old', 11, _f_model_season_month)
def _f_model_yearly_season_fourier(
a_x,
a_date,
params,
is_mult=False,
# cache params
a_t_fourier=None,
**kwargs):
if a_t_fourier is None:
a_t_fourier = _f_init_cache_a_t_fourier(None, a_date)
y = np.matmul(params, a_t_fourier)
return y
def _f_init_params_fourier_n_params(
n_params,
a_x=None,
a_y=None,
a_date=None,
is_mult=False):
if a_y is None:
params = np.random.uniform(0.001, 1, n_params)
else:
# max difference in time series
diff = a_y.max() - a_y.min()
params = diff * np.random.uniform(0.001, 1, n_params)
return params
def _f_init_params_fourier(a_x=None, a_y=None, a_date=None, is_mult=False):
n_params = 2 * _dict_fourier_config['harmonics']
return _f_init_params_fourier_n_params(
n_params, a_x=a_x, a_y=a_y, a_date=a_date, is_mult=is_mult)
def _f_init_bounds_fourier_nparams(n_params, a_x=None, a_y=None, a_date=None):
return n_params * [-np.inf], n_params * [np.inf]
def _f_init_bounds_fourier_yearly(a_x=None, a_y=None, a_date=None):
n_params = 2 * _dict_fourier_config['harmonics']
return _f_init_bounds_fourier_nparams(n_params, a_x, a_y, a_date)
model_season_fourier_yearly = ForecastModel(
name='season_fourier_yearly',
n_params=2 * _dict_fourier_config.get('harmonics'),
f_model=_f_model_yearly_season_fourier,
f_init_params=_f_init_params_fourier,
f_bounds=_f_init_bounds_fourier_yearly,
l_cache_vars='a_t_fourier'
)
def get_fixed_model(forecast_model, params_fixed, is_mult=False):
# Generate model with some fixed parameters
if forecast_model.n_params == 0: # Nothing to do
return forecast_model
if len(params_fixed) != forecast_model.n_params:
err = 'Wrong number of fixed parameters'
raise ValueError(err)
return ForecastModel(
forecast_model.name + '_fixed', 0,
f_model=lambda a_x, a_date, params, is_mult=is_mult, **kwargs:
forecast_model.f_model(
a_x=a_x, a_date=a_date, params=params_fixed, is_mult=is_mult))
def get_iqr_thresholds(s_diff, low=0.25, high=0.75):
# Get thresholds based on inter quantile range
q1 = s_diff.quantile(low)
q3 = s_diff.quantile(high)
iqr = q3 - q1
thr_low = q1 - 1.5 * iqr
thr_hi = q3 + 1.5 * iqr
return thr_low, thr_hi
# TODO: Add option - estimate_outl_size
# TODO: Add option - sigmoid steps
# TODO: ADD option - gaussian spikes
def get_model_outliers(df, window=3):
"""
Identify outlier samples in a time series
:param df: Input time series
:type df: pandas.DataFrame
:param window: The x-axis window to aggregate multiple steps/spikes
:type window: int
:return:
| tuple (mask_step, mask_spike)
| mask_step: True if sample contains a step
| mask_spike: True if sample contains a spike
:rtype: tuple of 2 numpy arrays of booleans
TODO: require minimum number of samples to find an outlier
"""
dfo = df.copy() # dfo - df for outliers
# If df has datetime index, use date logic in steps/spikes
with_dates = 'date' in df.columns
x_col = 'date' if with_dates else 'x'
if df[x_col].duplicated().any():
raise ValueError('Input cannot have multiple values per sample')
# Get the differences
dfo['dif'] = dfo.y.diff()
# We consider as outliers the values that are
# 1.5 * IQR (interquartile range) beyond the quartiles.
# These thresholds are obtained here
thr_low, thr_hi = get_iqr_thresholds(dfo.dif)
# Now identify the changes
dfo['ischange'] = ((dfo.dif < thr_low) | (dfo.dif > thr_hi)).astype(int)
# Whenever there are two or more consecutive changes
# (that is, within `window` samples), we group them together
dfo['ischange_group'] = (
dfo.ischange.rolling(window, win_type=None, center=True).max().fillna(
0).astype(int)
)
# We now have to calculate the difference within the
# same group in order to identify if the consecutive changes
# result in a step, a spike, or both.
# We get the filtered difference
dfo['dif_filt'] = (dfo.dif * dfo.ischange).fillna(0)
# And the absolute value of that
dfo['dif_filt_abs'] = dfo.dif_filt.abs()
dfo['change_group'] = dfo.ischange_group.diff(
).abs().fillna(0).astype(int).cumsum()
# this gets us the average difference of the outliers within each change
# group
df_mean_gdiff = (
dfo.loc[dfo.ischange.astype(bool)].groupby('change_group')[
'dif_filt'].mean().rename('mean_group_diff').reset_index())
# this gets us the average absolute difference of the outliers within each
# change group
df_mean_gdiff_abs = (
dfo.loc[dfo.ischange.astype(bool)].groupby('change_group')[
'dif_filt_abs'].mean().rename(
'mean_group_diff_abs').reset_index()
)
# Merge the differences with the original dfo
dfo = dfo.merge(
df_mean_gdiff,
how='left').merge(
df_mean_gdiff_abs,
how='left')
# Fill missing values with zero -> no change
dfo.mean_group_diff = dfo.mean_group_diff.fillna(0)
dfo.mean_group_diff_abs = dfo.mean_group_diff_abs.fillna(0)
# the change group is a step if the mean_group_diff exceeds the thresholds
dfo['is_step'] = dfo['ischange_group'] & (
((dfo.mean_group_diff < thr_low) | (dfo.mean_group_diff > thr_hi)))
# the change group is a spike if the difference between the
# mean_group_diff_abs and the average mean_group_diff exceeds
# the average threshold value
dfo['is_spike'] = (dfo.mean_group_diff_abs -
dfo.mean_group_diff.abs()) > (thr_hi - thr_low) / 2
# Get the outlier start and end points for each group
df_outl = (
dfo.loc[dfo.ischange.astype(bool)].groupby('change_group').apply(
lambda x: pd.Series(
{'outl_start': x[x_col].iloc[0],
'outl_end': x[x_col].iloc[-1]})).reset_index()
)
if df_outl.empty: # No outliers - nothing to do
return np.full(dfo.index.size, False), | np.full(dfo.index.size, False) | numpy.full |
import math
import numpy as np
from pydmfet import qcwrap,tools,libgen
def subocc_to_dens_part(P_ref, occ_imp, occ_bath, dim_imp, dim_bath):
dim = dim_imp + dim_bath
P_imp = np.zeros([dim,dim], dtype=float)
P_bath = np.zeros([dim,dim], dtype=float)
for i in range(dim):
if(i < dim_imp):
P_imp[i][i] = occ_imp[i]
else:
index = i-dim_imp
if(index >= dim_imp):
break
if(occ_imp[index] > 0.8):
P_imp[i][i] = 2.0 - occ_imp[index]
P_imp[i][index] = P_ref[i][index] #can't determine sign #math.sqrt(2.0*occ_imp[index] - occ_imp[index]**2)
P_imp[index][i] = P_imp[i][index]
else:
P_imp[index][index] = 0.0
'''
for i in range(dim):
if(i < dim_bath):
index = i+dim_imp
if(occ_imp[i] <= 0.8 or occ_bath[i] > 1.9):
P_bath[index][index] = occ_bath[i]
P_bath[i][index] = P_ref[i][index] #math.sqrt(2.0*occ_bath[i]-occ_bath[i]**2)
P_bath[index][i] = P_bath[i][index]
P_bath[i][i] = 2.0 - occ_bath[i]
'''
return (P_imp, P_bath)
def mulliken_partition_loc(frag_orbs,dm_loc):
dim = dm_loc.shape[0]
P_frag = np.zeros([dim,dim],dtype=float)
P_env = np.zeros([dim,dim],dtype=float)
for i in range(dim):
for j in range(dim):
if(frag_orbs[i] == 1 and frag_orbs[j] == 1):
P_frag[i,j] = dm_loc[i,j]
elif(frag_orbs[i] == 0 and frag_orbs[j] == 0):
P_env[i,j] = dm_loc[i,j]
else:
P_frag[i,j] = 0.5*dm_loc[i,j]
P_env[i,j] = 0.5*dm_loc[i,j]
print ("Ne_frag_loc = ", np.sum(np.diag(P_frag)))
print ("Ne_env_loc = ", np.sum(np.diag(P_env)))
return (P_frag,P_env)
def loc_fullP_to_fragP(frag_orbs,mo_coeff,NOcc,NOrb):
weight_frag = []
weight_env = []
for i in range(NOcc):
sum_frag = 0.0
sum_env = 0.0
for j in range(NOrb):
if(frag_orbs[j] == 1):
sum_frag += mo_coeff[j,i] * mo_coeff[j,i]
else:
sum_env += mo_coeff[j,i] * mo_coeff[j,i]
weight_frag.append(sum_frag)
weight_env.append(sum_env)
print (2.0*np.sum(weight_frag))
print (2.0*np.sum(weight_env))
P_frag = np.zeros([NOrb,NOrb],dtype=float)
P_env = np.zeros([NOrb,NOrb],dtype=float)
index = 0
dim = mo_coeff.shape[0]
mo_frag = np.zeros((dim,NOcc))
mo_occ = np.zeros((NOcc))
for i in range(NOcc):
P_tmp = 2.0*np.outer(mo_coeff[:,i], mo_coeff[:,i])
print (weight_frag[i], weight_env[i])
if(weight_frag[i] >= weight_env[i]):
P_frag = P_frag + P_tmp
mo_frag[:,index] = mo_coeff[:,i]
mo_occ[index] = 2.0
index +=1
else:
P_env = P_env + P_tmp
print ("Ne_frag_loc = ", np.sum(np.diag(P_frag)))
print ("Ne_env_loc = ", np.sum(np.diag(P_env)))
return (P_frag, P_env, mo_frag, mo_occ)
def fullP_to_fragP(obj, subTEI, Nelec,P_ref, dim, dim_imp, mf_method):
loc2sub = obj.loc2sub
core1PDM_loc = obj.core1PDM_loc
fock_sub = obj.ints.fock_sub( loc2sub, dim, core1PDM_loc)
energy, OneDM, mo_coeff = qcwrap.pyscf_rhf.scf( fock_sub, subTEI, dim, Nelec, P_ref, mf_method)
P_imp = np.zeros([dim, dim],dtype = float)
P_bath = np.zeros([dim, dim],dtype = float)
NOcc = Nelec//2
for i in range(NOcc):
isimp = classify_orb(mo_coeff[:,i],dim_imp)
P_tmp = 2.0*np.outer(mo_coeff[:,i], mo_coeff[:,i])
if isimp :
P_imp = P_imp + P_tmp
else :
P_bath = P_bath + P_tmp
print ("Ne_imp = ", np.sum(np.diag(P_imp)))
print ("Ne_bath = ", np.sum(np.diag(P_bath)))
print ("|P_imp + P_bath - P_ref| = ", np.linalg.norm(P_imp+P_bath-P_ref))
return (P_imp,P_bath)
def classify_orb(orb,dim_imp):
sum_imp = 0.0
for i in range(dim_imp):
sum_imp += orb[i]*orb[i]
print (sum_imp)
sum_bath = 1.0-sum_imp
if(sum_imp > sum_bath):
return True
else:
return False
def build_Pimp(occ,loc2sub,tokeep_imp,dim):
occ_loc = np.zeros([dim],dtype=float)
occ_loc[:tokeep_imp] = occ[:tokeep_imp]
Pimp_loc = np.dot( np.dot( loc2sub, np.diag( occ_loc ) ), loc2sub.T )
return Pimp_loc
def build_core(occ,loc2sub,idx_imp):
core_cutoff = 0.01
occ_frag = np.zeros( len(occ) ,dtype = float)
NOrb_imp = 0
for cnt in range(len(occ)):
if ( occ[ cnt ] < core_cutoff ):
occ[ cnt ] = 0.0
elif ( occ[ cnt ] > 2.0 - core_cutoff ):
occ[ cnt ] = 2.0
if(cnt < idx_imp):
NOrb_imp += 1
occ_frag[cnt] = 2.0
else:
print ("environment orbital occupation = ", occ[ cnt ])
raise Exception("subspace construction failed!")
Nelec_core = int(round(np.sum( occ )))
core1PDM_loc = np.dot( np.dot( loc2sub, np.diag( occ ) ), loc2sub.T )
frag_core1PDM_loc = np.dot( np.dot( loc2sub, np.diag( occ_frag ) ), loc2sub.T )
return (core1PDM_loc, Nelec_core, NOrb_imp, frag_core1PDM_loc)
def construct_subspace(ints,mol_frag,mol_env,OneDM, impurityOrbs, threshold=1e-13, dim_bath = None, dim_imp = None):
'''
Subspace construction
OneDM is in local orbital representation
'''
numImpOrbs = np.sum( impurityOrbs )
numTotalOrbs = len( impurityOrbs )
impOrbs = impurityOrbs.copy()
impOrbs = np.matrix(impOrbs)
if (impOrbs.shape[0] > 1):
impOrbs = impOrbs.T
isImp = np.dot( impOrbs.T , impOrbs ) == 1
imp1RDM = np.reshape( OneDM[ isImp ], ( numImpOrbs , numImpOrbs ) )
eigenvals_imp, eigenvecs_imp = fix_virt(ints, mol_frag, imp1RDM, numImpOrbs,numTotalOrbs, threshold)
tmp = []
for i in range(numImpOrbs):
if(eigenvals_imp[i] < threshold):
eigenvals_imp[i] = 0.0
elif(eigenvals_imp[i] > 2.0 - threshold):
eigenvals_imp[i] = 2.0
tmp.append(i)
if(len(tmp) == 0):
tmp.append(numImpOrbs-1)
last_imp_orb = -1
for i in range(tmp[0],-1,-1):
if(eigenvals_imp[i] > 1.99):
last_imp_orb = i
break
if(last_imp_orb == -1):
tokeep_imp = np.sum( -np.maximum( -eigenvals_imp, eigenvals_imp - 2.0 ) > threshold )
else:
tokeep_imp = last_imp_orb + 1
print ("occ_imp")
print (eigenvals_imp)
#print eigenvecs_imp
###############################################
embeddingOrbs = 1 - impurityOrbs
embeddingOrbs = np.matrix( embeddingOrbs )
if (embeddingOrbs.shape[0] > 1):
embeddingOrbs = embeddingOrbs.T # Now certainly row-like matrix (shape = 1 x len(vector))
isEmbedding = np.dot( embeddingOrbs.T , embeddingOrbs ) == 1
numEmbedOrbs = np.sum( embeddingOrbs )
embedding1RDM = np.reshape( OneDM[ isEmbedding ], ( numEmbedOrbs , numEmbedOrbs ) )
eigenvals_bath, eigenvecs_bath = fix_virt(ints, mol_frag, embedding1RDM, numEmbedOrbs,numTotalOrbs, threshold)
for i in range(numEmbedOrbs):
if(eigenvals_bath[i] < threshold):
eigenvals_bath[i] = 0.0
elif(eigenvals_bath[i] > 2.0-threshold):
eigenvals_bath[i] = 2.0
#if (tokeep_bath > tokeep_imp):
# print "Throwing out ", tokeep_bath - tokeep_imp, "bath orbitals"
# tokeep_bath = tokeep_imp
tokeep_bath = tokeep_imp #keep all bath orbitals
if(dim_bath is not None):
tokeep_bath = min(dim_bath, numTotalOrbs - numImpOrbs)
tokeep_imp = min(dim_bath,numImpOrbs)
if(dim_imp is not None):
tokeep_imp = min(dim_imp,numImpOrbs)
print ("occ_bath")
print (eigenvals_bath)
#print eigenvecs_bath
#tokeep_imp = numImpOrbs #keep all imp orbitals in the active space
if(tokeep_imp < numImpOrbs):
frozenEigVals_imp = -eigenvals_imp[tokeep_imp:]
frozenEigVecs_imp = eigenvecs_imp[:,tokeep_imp:]
idx = frozenEigVals_imp.argsort()
eigenvecs_imp[:,tokeep_imp:] = frozenEigVecs_imp[:,idx]
frozenEigVals_imp = -frozenEigVals_imp[idx]
eigenvals_imp[tokeep_imp:] = frozenEigVals_imp
frozenEigVals_bath = -eigenvals_bath[tokeep_bath:]
frozenEigVecs_bath = eigenvecs_bath[:,tokeep_bath:]
idx = frozenEigVals_bath.argsort()
eigenvecs_bath[:,tokeep_bath:] = frozenEigVecs_bath[:,idx]
frozenEigVals_bath = -frozenEigVals_bath[idx]
eigenvals_bath[tokeep_bath:] = frozenEigVals_bath
#print eigenvals_bath
#print eigenvecs_bath
loc2sub = eigenvecs_bath
for counter in range(0, numImpOrbs):
loc2sub = np.insert(loc2sub, counter, 0.0, axis=1) #Stack columns with zeros in the beginning
counter = 0
for counter2 in range(0, numTotalOrbs):
if ( impurityOrbs[counter2] ):
loc2sub = | np.insert(loc2sub, counter2, 0.0, axis=0) | numpy.insert |
import numpy as np
from scipy import interpolate,signal
import matplotlib.pyplot as plt
import math
from scipy.io import wavfile
import timeit
class FDSAF:
def __init__( self,filterlen):
self.M = filterlen
#self.w_f = np.fft.fft(np.concatenate((np.ones(1),np.zeros(2*self.M-1))))
self.w_f = np.fft.fft(np.zeros(2*self.M))
#self.w_f = np.fft.fft(np.concatenate((np.ones(self.M)/self.M,np.zeros(self.M))))
self.last_buffer = np.zeros(self.M, dtype='float')
self.Cm = np.matrix(0.5 * np.array([[-1,3,-3,1], # Row major
[2,-5,4,-1],
[-1,0,1,0],
[0,2,0,0]]))
# Based on paper example 1
self.mu_w = 0.001
self.mu_q = 0.001
self.delta_x = 0.2
self.ordinates = np.arange(-2.2,2.3,self.delta_x)
self.abscissas = np.arange(-2.2,2.3,self.delta_x) # Only for graphing
self.N = len(self.ordinates)-1
self.e = 0
# For sample-wise filtering
#self.w = np.concatenate((np.ones(1),np.zeros(self.M-1)))
self.w = np.zeros(self.M)
self.single_buffer = np.zeros(self.M)
def est(self, x, d):
if len(x) != self.M or len(d) != self.M:
print("Wrong input length")
exit()
full_buffer = np.concatenate((self.last_buffer,x))
x_f = np.fft.fft(full_buffer)
s = np.fft.ifft(x_f*self.w_f)[-self.M:]
UT = []
UdotT = []
QT = []
IT = []
for j in range(self.M):
i_j = int(np.floor(s[j].real/self.delta_x) + (self.N/2))
u_j = s[j].real/self.delta_x - np.floor(s[j].real/self.delta_x)
u = [math.pow(u_j,3),math.pow(u_j,2),u_j,1]
udot = [3*math.pow(u_j,2),2*u_j,1,0]
if (abs(s[j])>2.0):
q = np.asarray([(y-11)*self.delta_x for y in range(i_j-1,i_j+3)])
IT.append([-1,-1,-1,-1])
else:
q = np.asarray(list(self.ordinates[i_j-1:i_j+3]))
IT.append([i_j-1,i_j,i_j+1,i_j+2])
UT.append(u)
UdotT.append(udot)
QT.append(q)
Um = np.matrix(UT).T
Udotm = np.matrix(UdotT).T
Qm = np.matrix(QT).T
Im = np.matrix(IT).T
y = np.matmul(self.Cm,Qm)
y = np.multiply(y, Um)
y = np.asarray(y)
y = np.sum(y, axis=0)
self.e = d - y
deltadot = np.matmul(self.Cm,Qm)
deltadot = np.multiply(deltadot,Udotm)
deltadot = np.asarray(deltadot)
deltadot = np.sum(deltadot,axis=0)
e_s = np.multiply(deltadot/self.delta_x,self.e)
e_f = np.fft.fft(np.concatenate((np.zeros(self.M),e_s)))
deltaW = np.fft.ifft(np.multiply(e_f,np.conjugate(x_f)))[:self.M]
self.w_f = self.w_f + self.mu_w * np.fft.fft(np.concatenate((deltaW,np.zeros(self.M))))
temp = np.asarray(np.matmul(self.Cm.T,Um))
deltaq = self.mu_q * self.e * temp
Qm = Qm + deltaq
Qm = np.reshape(Qm,-1)
Im = np.reshape(Im,-1)
deltaq = np.reshape(deltaq,-1)
for i in range(np.shape(Im)[1]):
if Im[0,i] != -1:
self.ordinates[Im[0,i]] += deltaq[i]
self.last_buffer = x
return y
def estsingle(self, x, d):
# Filter
self.single_buffer[1:] = self.single_buffer[:-1]
self.single_buffer[0] = x
s = np.dot(self.single_buffer,self.w)
i_j = int(np.floor(s/self.delta_x) + (self.N/2))
u_j = s/self.delta_x - np.floor(s/self.delta_x)
u = np.asarray([math.pow(u_j,3),math.pow(u_j,2),u_j,1])
udot = np.asarray([3*math.pow(u_j,2),2*u_j,1,0])
if (abs(s)>2.0):
q = np.asarray([(y-11)*self.delta_x for y in range(i_j-1,i_j+3)])
else:
q = np.asarray(list(self.ordinates[i_j-1:i_j+3]))
y = np.matmul(u,self.Cm)
y = np.matmul(y, q)
y = float(y)
self.e = d - y
# Train filter
deltaw = np.matmul(self.mu_w*self.e*udot,self.Cm)
deltaw = float(np.matmul(deltaw, q))
self.w = self.w + deltaw*self.single_buffer
if abs(s) <= 2.0:
deltaq = | np.matmul(self.mu_q*self.e*self.Cm.T,u) | numpy.matmul |
# -*- coding: utf-8 -*-
#############################################################
# Copyright (c) 2020-2021 <NAME> #
# #
# This software is open-source and is distributed under the #
# BSD 3-Clause "New" or "Revised" License #
#############################################################
"""functions to check if everything is going OK"""
import mdtraj
import numpy as np
from scipy.spatial import ConvexHull # pylint: disable=no-name-in-module
def _in_ellipsoid(X, center, rotation_matrix, radii):
"""private"""
X = X.copy()
X -= center
X = rotation_matrix @ X
x = X[0]
y = X[1]
z = X[2]
result = (x / radii[0])**2 + (y / radii[1])**2 + (z / radii[2])**2
if result >= -1 and result <= 1: # pylint: disable=chained-comparison
return True
return False
def get_atoms_in_pocket(ligand,
pocket,
pdb_file,
top=None,
make_molecules_whole=False):
"""Get the number of ligand atoms in the given pocket
Parameters
-----------
ligand : str or list(int)
a mdtraj selection string or a list of atom indexes (0 indexed)
pocket : str or list(int)
a mdtraj selection string or a list of atom indexes (0 indexed)
pdb_file : str or path or list(str or path) or mdtraj.Trajectory
the path to any structure file supported by mdtraj.load (pdb, gro, ...)
or a mdtraj.Trajectory
top : str or path, optional
this is the top keywor argument in mdtraj.load
it is only needed if the structure file `pdb_file`
doesn't contain topology information
make_molecules_whole : bool, optional, default=False
if True make_molecules_whole() method will be called on the
mdtraj trajectory, I suggest not to use this option and to
give whole molecules as input
Notes
----------
This function uses mdtraj to parse the files
Then creates a hollow hull with ```scipy.spatial.ConvexHull```
Then fits is with an arbitrary ellipsoid
If at least `n_atoms_inside` atoms are inside the ellipsoid
the ligand is still in the pocket
Returns
-----------
int or list(int)
the number of atoms in the pocket
if more than a frame was given it will be a list
"""
if isinstance(pdb_file, mdtraj.Trajectory):
traj = pdb_file
else:
if isinstance(pdb_file, str) or not hasattr(pdb_file, '__iter__'):
pdb_file = [pdb_file]
#mdtraj can't manage Path objects
pdb_file = [str(i) for i in pdb_file]
if top is None:
# For a more omogeneus mdtraj.load function call
top = pdb_file[0]
else:
top = str(top)
traj = mdtraj.load(pdb_file, top=top)
#want only positive coordinates
if make_molecules_whole:
traj.make_molecules_whole(inplace=True)
if isinstance(ligand, str):
ligand = traj.top.select(ligand)
if isinstance(pocket, str):
pocket = traj.top.select(pocket)
ligand_coord = traj.atom_slice(ligand).xyz
pocket_coord = traj.atom_slice(pocket).xyz
#free memory
del traj
del ligand
del pocket
atoms_in_pocket_list = []
for ligand_frame, pocket_frame in zip(ligand_coord, pocket_coord):
atoms_in_pocket = 0
convex_hull_obj = ConvexHull(pocket_frame)
convex_hull = convex_hull_obj.points[convex_hull_obj.vertices]
center, rotation_matrix, radii, _ = ellipsoid_fit(convex_hull)
for atom in ligand_frame:
if _in_ellipsoid(atom, center, rotation_matrix, radii):
atoms_in_pocket += 1
atoms_in_pocket_list.append(atoms_in_pocket)
# I have a memory leak I couldn't
# identify maybe this helps
del convex_hull
del convex_hull_obj
if len(atoms_in_pocket_list) == 1:
return atoms_in_pocket_list[0]
return atoms_in_pocket_list
def check_ligand_in_pocket(ligand,
pocket,
pdb_file,
n_atoms_inside=1,
top=None,
make_molecules_whole=False):
"""Check if the ligand is in the pocket
If you used some kind of enhanced sampling before the FSDAM
or sometimes a simple equilibration the ligand may exit the
binding pocket and therefore you want to discard the frames relative
to this unwanted exits
Parameters
-----------
ligand : str or list(int)
a mdtraj selection string or a list of atom indexes (0 indexed)
pocket : str or list(int)
a mdtraj selection string or a list of atom indexes (0 indexed)
pdb_file : str or path or list(str or path)
the path to any structure file supported by mdtraj.load (pdb, gro, ...)
n_atoms_inside : int, optional, default=1
how many atoms of the ligand shall be inside the pocket to be considered
in the pocket. With the default 1 if at leas one atom of the ligand is in the defined pocket
the ligand is considered inside
top : str or path, optional
this is the top keywor argument in mdtraj.load
it is only needed if the structure file `pdb_file`
doesn't contain topology information
make_molecules_whole : bool, optional, default=False
if True make_molecules_whole() method will be called on the
mdtraj trajectory, I suggest not to use this option and to
give whole molecules as input
Notes
----------
This function uses mdtraj to parse the files
Then creates a hollow hull with ```scipy.spatial.ConvexHull```
Then fits is with an arbitrary ellipsoid
If at least `n_atoms_inside` atoms are inside the ellipsoid
the ligand is still in the pocket
Returns
-----------
bool or list(bool)
True if the ligand is in the pocket
False if the ligand is outside the pocket
If you gave a list of structures as input you
it will return a list of bool
"""
atoms_in_pocket_list = get_atoms_in_pocket(
ligand=ligand,
pocket=pocket,
pdb_file=pdb_file,
top=top,
make_molecules_whole=make_molecules_whole)
if not hasattr(atoms_in_pocket_list, '__iter__'):
atoms_in_pocket_list = [atoms_in_pocket_list]
is_in_pocket = []
for atoms_in_pocket in atoms_in_pocket_list:
if atoms_in_pocket < n_atoms_inside:
is_in_pocket.append(False)
else:
is_in_pocket.append(True)
if len(is_in_pocket) == 1:
return is_in_pocket[0]
return is_in_pocket
# https://github.com/aleksandrbazhin/ellipsoid_fit_python/blob/master/ellipsoid_fit.py
# http://www.mathworks.com/matlabcentral/fileexchange/24693-ellipsoid-fit
# for arbitrary axes
# (Under MIT license)
def ellipsoid_fit(X):
"""fits an arbitrary ellipsoid to a set of points
"""
x = X[:, 0]
y = X[:, 1]
z = X[:, 2]
D = np.array([
x * x + y * y - 2 * z * z, x * x + z * z - 2 * y * y, 2 * x * y,
2 * x * z, 2 * y * z, 2 * x, 2 * y, 2 * z, 1 - 0 * x
])
d2 = np.array(x * x + y * y + z * z).T # rhs for LLSQ
u = np.linalg.solve(D.dot(D.T), D.dot(d2))
a = np.array([u[0] + 1 * u[1] - 1])
b = np.array([u[0] - 2 * u[1] - 1])
c = np.array([u[1] - 2 * u[0] - 1])
v = | np.concatenate([a, b, c, u[2:]], axis=0) | numpy.concatenate |
# from __future__ import division
#-------------------------------------
#
# Started at 06/08/2018 (YuE)
#
# This script based on the previous script
# threeApproachesComparison_v6.py
#
## Upgraded version of python (python3.4): script was rewritten to take into
# account some differences in the descriptions and using of some functions
# (version cma_v3 and more earlier scripts are written under python2).
#
# 07/24/2018: IT IS NOT FINISHED:
#
# Which are still unsatisfactory:
# 1) the absolute values of frictional forces for all methods of calculation,
# 2) their dependence on the ion velocity.
#
# But nevertheless, the dependences of the transmitted energy on the impact
# parameter are close to the inverse quadratic (as it should be!) at all velocities.
#
# 07/27/2018: IT IS NOT FINISHED:
#
# Which are still unsatisfactory:
# 1) the absolute values of frictional forces for all methods of calculation,
# 2) their dependence on the ion velocity.
# The investigation of that is in progress.
#
# Some features were improved, some figures were corrected.
#
#-------------------------------------
#========================================================
#
# This code compairs two approaches: "classical" (from [1]) and
# "magnus" (from [2]).
#
# For "classical" approach the magnetized interaction between ion
# and electron is considered for ion velocities V_i > rmsTrnsvVe.
#
# References:
#
# [1] <NAME>, <NAME>, <NAME>, <NAME>.
# "Physics guide of BETACOOL code. Version 1.1". C-A/AP/#262, November
# 2006, Brookhaven National Laboratory, Upton, NY 11973.
# [2] <NAME>, <NAME>. "New Algorithm for Dynamical Friction
# of Ions in a Magnetized Electron Beam". AIP Conf. Proc. 1812, 05006 (2017).
#
#========================================================
#########################################################
#
# Main issues of the calculations:
#
# 1) Friction force (FF) is calculated in the (P)article (R)est (F)rame,
# i.e. in the frame moving together with both (cooled and cooling)
# beams at a velocity V0;
# 2) Friction force is calculated for each value of ion velocity
# in the interval from .1*rmsTrnsvVe till 10*rmsTrnsvVe;
# 3) Initially assumped that all electrons have a logitudinal
# velocity rmsLongVe and transversal velocity rmsTrnsvVe;
# 4) For each ion velocity the minimal and maximal values of the
# impact parameter are defined. Radius of the shielding of the
# electric field of the ion equals to the value of the maximal
# impact parameter;
# 5) For each impact parameter in the interval from minimal till
# maximal values the transfered momenta deltap_x,y,z are
# calculated;
# 6) Founded transfered momenta allow to calculate the transfered
# energy delta_E =deltap^2/(2*m_e) and to integrate it over
# impact parameter; then (expressions (3.4), (3.5) from [1]):
# FF =-2*pi*n_e*integral_rhoMin^rhoMax delta_E*rho*drho;
# 7) For taking into account the velocity distribution of the
# electrons it is necessary to repeat these calculations for
# each value of the electron's velocity and then integrate result
# over distribution of the velocities.
#
# 10/26/2018:
#
# 8) Item 6 is wrong and correct expression for transfered
# energy delta_E will be used;
# 9) Method (my own) Least Squares Method - LSM is used to fit the
# dependence of transferred momenta on impact parameter;
#
#
# 11/08/2018:
#
# 10) Two functions ('fitting' and 'errFitAB' are defined to realize
# my LSM to find the parameters of the fitting end error of this
# fitting;
#
# 11) Analys of different dependeces between values; graphical
# presentation of these dependences;
#
#########################################################
import os, sys
import numpy as np
import math
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from matplotlib.colors import LogNorm
from matplotlib import ticker
from matplotlib import markers
import matplotlib as mpl
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
from matplotlib.legend_handler import HandlerLine2D
import scipy.integrate as integrate
from scipy.integrate import quad, nquad, dblquad
from scipy.constants import pi
from scipy import optimize
from statistics import mean
from array import array
#
# All physical constants have its dimension in units in the system CI.
# This code uses units in the system CGS!
#
from scipy.constants import speed_of_light as clight
from scipy.constants import epsilon_0 as eps0
from scipy.constants import mu_0 as mu0
from scipy.constants import elementary_charge as qe
from scipy.constants import electron_mass as me
from scipy.constants import proton_mass as mp
from scipy.constants import Boltzmann as kB
pi=3.14159265358
#
# Physical constants:
#
m_e=9.10938356e-28 # electron mass, g
m_elec=m_e # to keep variable from previous script
m_p=1.672621898e-24 # electron mass, g
M_ion = m_p # to keep variable from previous script
q_e=4.803204673e-10 # electron charge, CGSE unit: sqrt(g*cm^3/sec^2)
q_elec=q_e # to keep variable from previous script
Z_ion = q_e # to keep variable from previous script
cLight=2.99792458e10 # speed of light, cm/sec
eVtoErg=1.6021766208e-12 # 1 eV = 1.6...e-12 erg
CtoPart=2.99792458e9 # 1 C = 1 A*sec = 2.9...e9 particles
m_e_eV = m_e*cLight**2/eVtoErg
#
# Electron beam parameters:
#
Ekin=3.0e4 # kinetic energy, eV
curBeam=0.5 # current density, A/cm^2
dBeam=3.0 # beam diameter, cm
angSpread=3.0 # angular spread, mrad
trnsvT=0.5 # transversal temperature, eV
longT=2.0e-4 # longitudinal temperature, eV (was 2.0e-4)
nField=1 # number ov values of the magnetic field
fieldB=np.zeros(nField) # magnetic field
fieldB[0]=3.e3 # Gs
omega_p=1.0e9 # plasma frequency, 1/sec
n_e=omega_p**2*m_e/(4.*pi*q_e**2) # plasma density, 3.1421e+08 cm-3
n_e1=8.e7 # plasma density, cm-3
omega_p1=np.sqrt(4.*pi*n_e1*q_e**2/m_e) # plasma frequency, 5.0459e+08 1/s
#
# Cooling system parameter:
#
coolLength=150.0 # typical length of the coolong section, cm
#
# HESR:
#
Ekin=90.8e4 # HESR kinetic energy, eV
curBeam=0.5 # HESR current beam, A
dBeam=2.0 # HESR beam diameter, cm
angSpread=0.0 # HESR angular spread, mrad
trnsvT=0.2 # HESR transversal temperature, eV
longT=1.0e-2 # HESR longitudinal temperature, eV (was 2.0e-4)
fieldB[0]=1.e3 # HESR, Gs
coolLength=270.0 # HESR typical length of the coolong section, cm
#
# EIC:
#
angSpread=0.0 # EIC angular spread, mrad
fieldB[0]=5.e4 # EIC, Gs
coolLength=300.0 # EIC typical length of the coolong section, cm
#
# Calculated parameters of the electron beam:
#
V0 = cLight*np.sqrt(Ekin/m_e_eV*(Ekin/m_e_eV+2.))/(Ekin/m_e_eV+1.)
print ('V0 =%e' % V0)
tetaV0=0. # angle between V0 and magnetic field, rad
B_mag=fieldB[0]*np.cos(tetaV0) # magnetic field acting on an electron, Gs
rmsTrnsvVe=np.sqrt(2.*trnsvT*eVtoErg/m_e) # RMS transversal velocity, cm/s
rmsLongVe=np.sqrt(2.*longT*eVtoErg/m_e) # RMS longitudinal velocity, cm/s
# HESR:
dens=curBeam*(CtoPart/q_e)/(pi*(.5*dBeam)**2*V0) # density, 1/cm^3
omega=np.sqrt(4.*pi*dens*q_e**2/m_e) # plasma frequency, 1/s
n_e=dens
omega_p=omega
print ('HESR: dens = %e,omega_p = %e' % (dens,omega_p))
# EIC:
rmsLongVe = 1.0e+7 # cm/s
longT = .5*m_e*rmsLongVe**2/eVtoErg
rmsTrnsvVe = 4.2e+7 # cm/s
trnsvT = .5*m_e*rmsTrnsvVe**2/eVtoErg
print ('EIC: rmsLongVe = %e, longT = %e, rmsTrnsvVe = %e, trnsvT = %e' % \
(rmsLongVe,longT,rmsTrnsvVe,trnsvT))
dens=2.e9 # density, 1/cm^3
omega=np.sqrt(4.*pi*dens*q_e**2/m_e) # plasma frequency, 1/s
n_e=dens
omega_p=omega
print ('EIC: dens = %e,omega_p = %e' % (dens,omega_p))
cyclFreq=q_e*B_mag/(m_e*cLight) # cyclotron frequency, 1/s
rmsRoLarm=rmsTrnsvVe*cyclFreq**(-1) # RMS Larmor radius, cm
dens=omega_p**2*m_e/(4.*pi*q_e**2) # density, 1/cm^3
likeDebyeR=(3./dens)**(1./3.) # "Debye" sphere with 3 electrons, cm
eTempTran=trnsvT # to keep variable from previous script
eTempLong=longT # to keep variable from previous script
coolPassTime=coolLength/V0 # time pass through cooling section, cm
thetaVi=0. # polar angle ion and cooled electron beams, rad
phiVi=0. # azimuth angle ion and cooled electron beams, rad
powV0=round(np.log10(V0))
mantV0=V0/(10**powV0)
pow_n_e=round(np.log10(n_e))
mant_n_e=n_e/(10**pow_n_e)
#
# Formfactor ffForm for friction force:
#
# ffForm = 2*pi*dens*q_e**4/(m_e*V0**2)=
# = 0.5*omega_p**2*q_e**2/V0**2
#
# Dimension of ffForm is force: g*cm/sec**2=erg/cm
#
# 1 MeV/m = 1.e6*eVtoErg/100. g*cm/sec**2 = 1.e4*eVtoErg erg/cm
MeV_mToErg_cm=1.e4*eVtoErg
# ffForm=-.5*omega_p**2*q_e**2/V0**2/MeV_mToErg_cm # MeV/m
eV_mToErg_m=100.*eVtoErg
# ffForm=-.5*omega_p**2*q_e**2/V0**2/eV_mToErg_m # =-6.8226e-12 eV/m
eV_mInErg_cm=100.*eVtoErg
ffForm=-.5*omega_p**2*q_e**2/V0**2/eVtoErg # =-6.8226e-10 eV/cm
ffForm=100.*ffForm # =-6.8226e-08 eV/m
ergToEV = 1./1.60218e-12
#
# Relative velocities of electrons:
#
relVeTrnsv=rmsTrnsvVe/V0
relVeLong=rmsLongVe/V0
print ('V0=%e cm/s, rmsTrnsvVe=%e cm/s (rel = %e), rmsLongVe=%e cm/s (rel = %e)' % \
(V0,rmsTrnsvVe,relVeTrnsv,rmsLongVe,relVeLong))
# Indices:
(Ix, Ipx, Iy, Ipy, Iz, Ipz) = range(6)
stepsNumberOnGyro = 25 # number of the steps on each Larmour period
'''
#
# Opening the input file:
#
inputFile='areaOfImpactParameter_tAC-v6_fig110.data'
print ('Open input file "%s"...' % inputFile)
inpfileFlag=0
try:
inpfile = open(inputFile,'r')
inpfileFlag=1
except:
print ('Problem to open input file "%s"' % inputFile)
if inpfileFlag == 1:
print ('No problem to open input file "%s"' % inputFile)
lines=0 # Number of current line from input file
dataNumber=0 # Number of current value of any types of Data
xAboundary=np.zeros(100)
xBboundary=np.zeros(100)
while True:
lineData=inpfile.readline()
# print ('line=%d: %s' % (lines,lineData))
if not lineData:
break
lines += 1
if lines > 4:
words=lineData.split()
nWords=len(words)
# print ('Data from %d: words=%s, number of entries = %d' % (lines,words,nWords))
xAboundary[dataNumber]=float(words[0])
xBboundary[dataNumber]=float(words[1])
dataNumber += 1
inpfile.close()
print ('Close input file "%s"' % inputFile)
'''
#====================================================================
#
#------------------ Begin of defined functions -----------------------
#
# Larmor frequency electron:
#
def omega_Larmor(mass,B_mag):
return (q_elec)*B_mag/(mass*clight*1.e+2) # rad/sec
#
# Derived quantities:
#
omega_L = omega_Larmor(m_elec,B_mag) # rad/sec
T_larm = 2*pi/omega_L # sec
timeStep = T_larm/stepsNumberOnGyro # time step, sec
print ('omega_Larmor= %e rad/sec, T_larm = %e sec, timeStep = %e sec' % \
(omega_L,T_larm,timeStep))
nLarmorAvrgng=10 # number of averaged Larmor rotations
#
# Data to integrate transferred momemta over the track:
#
timeStep_c=nLarmorAvrgng*stepsNumberOnGyro*timeStep # sec
print ('timeStep_c = %e s' % timeStep_c)
eVrmsTran = np.sqrt(2.*eTempTran*eVtoErg/m_elec) # cm/sec
eVrmsLong = np.sqrt(2.*eTempLong*eVtoErg/m_elec) # cm/sec
kinEnergy = m_elec*(eVrmsTran**2+eVrmsLong**2)/2. # kinetic energy; erg
print ('eVrmsTran = %e cm/sec, eVrmsLong = %e cm/sec, kinEnergy = %e eV' % \
(eVrmsTran,eVrmsLong,ergToEV*kinEnergy))
ro_larmRMS = eVrmsTran/omega_L # cm
print ('ro_larmRMS =%e mkm' % (1.e4*ro_larmRMS))
#
# Electrons are magnetized for impact parameter >> rhoCrit:
#
rhoCrit=math.pow(q_elec**2/(m_elec*omega_L**2),1./3) # cm
print ('rhoCrit (mkm) = ' , 1.e+4*rhoCrit)
#
# Convertion from 6-vector of relectron's "coordinates" to 6-vector
# of guiding-center coordinates:
# z_e=(x_e,px_e,y_e,py_e,z_e,pz_e) --> zgc_e=(phi,p_phi,y_gc,p_gc,z_e,pz_e);
#
def toGuidingCenter(z_e):
mOmega=m_elec*omega_L # g/sec
zgc_e=z_e.copy() # 6-vector
zgc_e[Ix] = np.arctan2(z_e[Ipx]+mOmega*z_e[Iy],z_e[Ipy]) # radians
zgc_e[Ipx]= (((z_e[Ipx]+mOmega*z_e[Iy])**2+z_e[Ipy]**2)/(2.*mOmega)) # g*cm**2/sec
zgc_e[Iy] =-z_e[Ipx]/mOmega # cm
zgc_e[Ipy]= z_e[Ipy]+mOmega*z_e[Ix] # g/sec
return zgc_e
#
# Convertion from 6-vector of guiding-center coordinates to 6-vector
# of electron's "coordinates":
# zgc_e=(phi,p_phi,y_gc,p_gc,z_e,pz_e) --> z_e=(x_e,px_e,y_e,py_e,z_e,pz_e);
#
def fromGuidingCenter(zgc_e):
mOmega=m_elec*omega_L # g/sec
rho_larm=np.sqrt(2.*zgc_e[Ipx]/mOmega) # cm
z_e = zgc_e.copy() # 6-vector
z_e[Ix] = zgc_e[Ipy]/mOmega-rho_larm*np.cos(zgc_e[Ix]) # cm
z_e[Ipx]=-mOmega*zgc_e[Iy] # g*cm/sec
z_e[Iy] = zgc_e[Iy]+rho_larm*np.sin(zgc_e[Ix]) # cm
z_e[Ipy]= mOmega*rho_larm*np.cos(zgc_e[Ix]) # g*cm/sec
return z_e
#
# Matrix to dragg electron through the solenoid with field 'B_mag'
# during time interval 'deltaT':
#
def solenoid_eMatrix(B_mag,deltaT):
slndMtrx=np.identity(6)
omega_L=omega_Larmor(m_elec,B_mag) # rad/sec
mOmega= m_elec*omega_L # g/sec
phi=omega_L*deltaT # phase, rad
cosPhi=math.cos(phi) # dimensionless
sinPhi=math.sin(phi) # dimensionless
cosPhi_1=2.*math.sin(phi/2.)**2 # dimensionless
slndMtrx[Iy, Iy ]= cosPhi # dimensionless
slndMtrx[Ipy,Ipy]= cosPhi # dimensionless
slndMtrx[Iy, Ipy]= sinPhi/mOmega # sec/g
slndMtrx[Ipy,Iy ]=-mOmega*sinPhi # g/sec
slndMtrx[Iz, Ipz]= deltaT/m_elec # sec/g
slndMtrx[Ix, Ipx]= sinPhi/mOmega # sec/g
slndMtrx[Ix, Iy ]= sinPhi # dimensionless
slndMtrx[Ix, Ipy]= cosPhi_1/mOmega # sec/g
slndMtrx[Iy, Ipx]=-cosPhi_1/mOmega # sec/g
slndMtrx[Ipy,Ipx]=-sinPhi # dimensionless
return slndMtrx
#
# Matrix to dragg particle through the drift during time interval 'deltaT':
#
def drift_Matrix(M_prtcl,deltaT):
driftMtrx = np.identity(6)
for i in (Ix,Iy,Iz):
driftMtrx[i,i+1]=deltaT/M_prtcl # sec/g
return driftMtrx
#
# Matrix to dragg electron in the "guiding center" system during time interval 'deltaT':
#
def guidingCenter_Matrix(deltaT):
gcMtrx = np.identity(6)
gcMtrx[Iz,Ipz]=deltaT/m_elec # sec/g
return gcMtrx
#
# Description of the collision during time interval 'deltaT'
# in the system coordinates of "guiding center" of electron
# input - 6-vectors for electron and ion before collision and time step deltaT;
# output - transfered momenta to ion and electron:
#
def guidingCenterCollision(vectrElec_gc,vectrIon,deltaT):
dpIon=np.zeros(3)
dpElec=np.zeros(3)
mOmegaLarm=m_elec*omega_L # g/sec
dpFactor_gc=q_elec**2 # g*cm^3/sec^2
rhoLarm_gc=np.sqrt(2.*vectrElec_gc[1]/mOmegaLarm) # cm
sinOmega_gc=math.sin(vectrElec_gc[0])
cosOmega_gc=math.cos(vectrElec_gc[0])
x_gc=vectrElec_gc[3]/mOmegaLarm # cm
numer=(vectrIon[0]-x_gc)*cosOmega_gc- \
(vectrIon[2]-vectrElec_gc[2])*sinOmega_gc # cm
denom=((vectrIon[0]-x_gc)**2+(vectrIon[2]-vectrElec_gc[2])**2+ \
(vectrIon[4]-vectrElec_gc[4])**2+rhoLarm_gc**2)**(3/2) # cm^3
action=vectrElec_gc[1]+dpFactor_gc*numer*rhoLarm_gc/(omega_L*denom) # g*cm^2/sec
b_gc=np.sqrt((vectrIon[0]-x_gc)**2+ \
(vectrIon[2]-vectrElec_gc[2])**2+ \
(vectrIon[4]-vectrElec_gc[4])**2+2.*action/mOmegaLarm) # cm
# Dimensions of dpIon, deElec are g*cm/sec:
dpIon[0]=-dpFactor_gc*deltaT*(vectrIon[0]-x_gc)/b_gc**3
dpIon[1]=-dpFactor_gc*deltaT*(vectrIon[2]-vectrElec_gc[2])/b_gc**3
dpIon[2]=-dpFactor_gc*deltaT*(vectrIon[4]-vectrElec_gc[4])/b_gc**3
dpElec[0]=-dpIon[0]
dpElec[1]=-dpIon[1]
dpElec[2]=-dpIon[2]
# print ('dpIon[0]=%e, dpIon[1]=%e, dpIon[2]=%e' % \
# (dpIon[0],dpIon[1],dpIon[2]))
return dpIon,dpElec,action,b_gc
#
# "Magnus expansion" description of the collision during time interval 'deltaT'
# in the system coordinates of "guiding center" of electron
# input - 6-vectors for electron and ion before collision and time step deltaT;
# output - transfered momenta to ion and electron and electron y_gc coordinate
# as well calculated parameters C1,C2,C3,b,D1,D2,q for testing:
#
def MagnusExpansionCollision(vectrElec_gc,vectrIon,deltaT):
# print ('Ion: x=%e, y=%e, z=%e' % (vectrIon[0],vectrIon[2],vectrIon[4]))
# print ('Electron: x=%e, y=%e, z=%e' %
# (vectrElec_gc[0],vectrElec_gc[4],vectrElec_gc[4]))
dpIon=np.zeros(3)
dpElec=np.zeros(3)
mOmegaLarm=m_elec*omega_L # g/sec
dpFactor_gc=q_elec**2 # g*cm^3/sec^2
rhoLarm_gc=np.sqrt(2.*vectrElec_gc[1]/mOmegaLarm) # cm
sinOmega_gc=math.sin(vectrElec_gc[0])
cosOmega_gc=math.cos(vectrElec_gc[0])
x_gc=vectrElec_gc[3]/mOmegaLarm # cm
numer=(vectrIon[0]-x_gc)*cosOmega_gc- \
(vectrIon[2]-vectrElec_gc[2])*sinOmega_gc # cm
denom=((vectrIon[0]-x_gc)**2+(vectrIon[2]-vectrElec_gc[2])**2+ \
(vectrIon[4]-vectrElec_gc[4])**2+rhoLarm_gc**2)**(3./2.) # cm^3
action=vectrElec_gc[1]+dpFactor_gc*numer*rhoLarm_gc/(omega_L*denom) # g*cm^2/sec
# C1=np.sqrt((vectrIon[0]-x_gc)**2+ \
# (vectrIon[2]-vectrElec_gc[2])**2+ \
# (vectrIon[4]-vectrElec_gc[4])**2+2.*action/mOmegaLarm) # cm^2
C1=(vectrIon[0]-x_gc)**2+(vectrIon[2]-vectrElec_gc[2])**2+ \
(vectrIon[4]-vectrElec_gc[4])**2+2.*action/mOmegaLarm # cm^2
C2=2.*((vectrIon[0]-x_gc)*vectrIon[1]/M_ion+ \
(vectrIon[2]-vectrElec_gc[2])*vectrIon[3]/M_ion+ \
(vectrIon[4]-vectrElec_gc[4])* \
(vectrIon[5]/M_ion-vectrElec_gc[5]/m_elec)) # cm^2/sec
C3=(vectrIon[1]/M_ion)**2+(vectrIon[3]/M_ion)**2+ \
(vectrIon[5]/M_ion-vectrElec_gc[5]/m_elec)**2 # cm^2/sec^2
b=np.sqrt(C1+C2*deltaT+C3*deltaT**2) # cm
D1=(2.*C3*deltaT+C2)/b-C2/np.sqrt(C1) # cm/sec
D2=(C2*deltaT+2.*C1)/b-2.*np.sqrt(C1) # cm
q=4.*C1*C3-C2**2 # cm^4/sec^2
# Dimensions of dpIon, deElec are g*cm/sec:
dpIon[0]=-2.*dpFactor_gc/q*((vectrIon[0]-x_gc)*D1-vectrIon[1]/M_ion*D2)
dpIon[1]=-2.*dpFactor_gc/q*((vectrIon[2]-vectrElec_gc[2])*D1- \
vectrIon[3]/M_ion*D2)
dpIon[2]=-2.*dpFactor_gc/q*((vectrIon[4]-vectrElec_gc[4])*D1- \
(vectrIon[5]/M_ion-vectrElec_gc[5]/m_elec)*D2)
dpElec[0]=-dpIon[0]
dpElec[1]=-dpIon[1]
dpElec[2]=-dpIon[2]
dy_gc=dpIon[0]/mOmegaLarm # cm
# print ('dpIon[0]=%e, dpIon[1]=%e, dpIon[2]=%e' % \
# (dpIon[0],dpIon[1],dpIon[2]))
return dpIon,dpElec,action,dy_gc,C1,C2,C3,b,D1,D2,q
#
# Minimized functional (my own Least Squares Method - LSM;
# Python has own routine for LSM - see site
# http://scipy-cookbook.readthedocs.io/items/FittingData.html):
#
# Funcional = {log10(funcY) - [fitB*log10(argX) + fitA]}^2
#
def fitting(nPar1,nPar2,argX,funcY):
log10argX = np.zeros((nPar1,nPar2))
log10funcY = np.zeros((nPar1,nPar2))
for i in range(nVion):
for n in range(nPar1):
log10argX[n,i] = np.log10(argX[n,i])
log10funcY[n,i] = np.log10(funcY[n,i])
sumArgX = np.zeros(nPar2)
sumArgX2 = np.zeros(nPar2)
sumFuncY = np.zeros(nPar2)
sumArgXfuncY= np.zeros(nPar2)
fitA = np.zeros(nPar2)
fitB = np.zeros(nPar2)
for i in range(nPar2):
for n in range(nPar1):
sumArgX[i] += log10argX[n,i]
sumArgX2[i] += log10argX[n,i]**2
sumFuncY[i] += log10funcY[n,i]
sumArgXfuncY[i] += log10argX[n,i]*log10funcY[n,i]
delta = sumArgX[i]**2-nPar1*sumArgX2[i]
fitA[i] = (sumArgX[i]*sumArgXfuncY[i]-sumArgX2[i]*sumFuncY[i])/delta
fitB[i] = (sumArgX[i]*sumFuncY[i]-nPar1*sumArgXfuncY[i])/delta
# print ('fitA(%d) = %e, fitB(%d) = %e' % (i,fitA[i],i,fitB[i]))
argXfit = np.zeros((nPar1,nPar2))
funcYfit = np.zeros((nPar1,nPar2))
funcHi2 = np.zeros(nPar2)
for i in range(nPar2):
factorA = math.pow(10.,fitA[i])
for n in range(nPar1):
argXfit[n,i] = math.pow(10.,log10argX[n,i])
funcYfit[n,i] = factorA*math.pow(argXfit[n,i],fitB[i])
funcHi2[i] += (np.log10(abs(funcY[n,i])) - np.log10(abs(funcYfit[n,i])))**2
return fitA,fitB,funcHi2,argXfit,funcYfit
#
# +-Errors for fitied parameters fitA and fitB:
#
def errFitAB(nPar1,nPar2,argX,funcY,fitA,fitB,funcHi2,errVar,errType):
log10argX = np.zeros((nPar1,nPar2))
log10funcY = np.zeros((nPar1,nPar2))
sumArgX = np.zeros(nPar2)
sumArgX2 = np.zeros(nPar2)
posErrFit = np.zeros(nPar2)
negErrFit = np.zeros(nPar2)
# return posErrFit,negErrFit
stepA = 5.e-4*mean(funcHi2)
stepB = 1.e-4*mean(funcHi2)
# print ('errFitAB: mean(funcHi2) = %e, stepA = %e, stepB = %e' % (mean(funcHi2),stepA,stepB))
for i in range(nPar2):
for n in range(nPar1):
log10argX[n,i] = np.log10(argX[n,i])
log10funcY[n,i] = np.log10(funcY[n,i])
sumArgX[i] += log10argX[n,i]
sumArgX2[i] += log10argX[n,i]**2
for i in range(nPar2):
k = 0
deltaFuncHi2 = 0.
while (deltaFuncHi2 < 1.):
k += 1
if k > 2000:
print ('Break in errFitAB (Fit funcY: case %d); positive error) for %d' % (errVar,i))
break
# print ('i=%d: fitParamtr = %e, funcHi2 = %e' % (i,fitParamtr[i], funcHi2[i]))
curFitA = fitA[i]
if (int(errVar) == 1):
curFitA = fitA[i] + k*stepA
curFuncHi2 = 0.
factorA = math.pow(10.,curFitA)
curFitB = fitB[i]
if (int(errVar) == 2):
curFitB = fitB[i] + k*stepB
curFuncHi2 = 0.
for n in range(nPar1):
curArgX = math.pow(10.,log10argX[n,i])
curFuncYfit = factorA*math.pow(curArgX,curFitB)
curFuncHi2 += (np.log10(abs(curFuncYfit)) - log10funcY[n,i])**2
deltaFuncHi2 = curFuncHi2 - funcHi2[i]
if (int(errVar) == 1):
posErrFit[i] = abs(curFitA - fitA[i])
else:
posErrFit[i] = abs(curFitB - fitB[i])
func1sigma2 = funcHi2[i]/(nPar2-3)
if (int(errVar) == 1):
fitSigma = np.sqrt(sumArgX2[i]/(nPar2*sumArgX2[i]-sumArgX[i]**2)*func1sigma2)
else:
fitSigma = np.sqrt(nPar2/(nPar2*sumArgX2[i]-sumArgX[i]**2)*func1sigma2)
if (int(errType) == 2):
posErrFit[i] = fitSigma
# if (int(errVar) == 1):
# print ('i=%d: fitA = %e + %e (%e), funcHi2 = %e (for %d steps curFuncHi2 = %e)' % \
# (i,fitA[i],posErrFit[i],fitSigma,funcHi2[i],k,curFuncHi2))
# else:
# print ('i=%d: fitB = %e + %e (%e), funcHi2 = %e (for %d steps curFuncHi2 = %e)' % \
# (i,fitB[i],posErrFit[i],fitSigma,funcHi2[i],k,curFuncHi2))
for i in range(nPar2):
k = 0
deltaFuncHi2 = 0.
while (deltaFuncHi2 < 1.):
k += 1
if k > 2000:
print ('Break in errFitAB (Fit funcY: case %d); negative error) for %d' % (errVar,i))
break
curFitA = fitA[i]
if (int(errVar) == 1):
curFitA = fitA[i] - k*stepA
factorA = math.pow(10.,curFitA)
curFitB = fitB[i]
if (int(errVar) == 2):
curFitB = fitB[i] - k*stepB
curFuncHi2 = 0.
for n in range(nPar1):
curArgX = math.pow(10.,log10argX[n,i])
curFuncYfit = factorA*math.pow(curArgX,curFitB)
curFuncHi2 += (np.log10(abs(curFuncYfit)) - log10funcY[n,i])**2
deltaFuncHi2 = curFuncHi2 - funcHi2[i]
if (int(errVar) == 1):
negErrFit[i] = abs(curFitA - fitA[i])
else:
negErrFit[i] = abs(curFitB - fitB[i])
if (int(errType) == 2):
negErrFit[i] = posErrFit[i]
# if (errVar == 1):
# print ('i=%d: fitA = %e - %e, funcHi2 = %e (for %d steps curFuncHi2 = %e)' % \
# (i,fitA[i],posErrFit[i],funcHi2[i],k,curFuncHi2))
# else:
# print ('i=%d: fitB = %e - %e, funcHi2 = %e (for %d steps curFuncHi2 = %e)' % \
# (i,fitB[i],negErrFit[i],funcHi2[i],k,curFuncHi2))
return posErrFit,negErrFit
def fittedGKintegration(xMin,xMax,fitA,fitB):
#
# "Gauss-Kronrod" method of integration (GK)
#
#
# Points (psi_i) and weigths (w_i) to integrate for interval from -1 to 1;
# These data are from <NAME>. "Handbook of Mathematical Science".
# 5th Edition, CRC Press, Inc, 1978.
#
# To integrate for interval from 0 to 1 it is necessary to change points
# psi_i with points ksi_i=(1+psi_i)/2;
#
# For method with order N for function F(x):
# int_(-1)^1 = sum_1^N [w_i* F(psi_i)];
#
# In case of integration over interval from a to b:
# int_(a)^b = (b-a)/2 * sum_1^N [w_i* F(x_i)], where
# x_i = (b-a)*psi_i/2+(a+b)/2.
#
#----------------------------------------------------
#
# Data for GK:
#
#----------------------------------------------------
nPoints_GK = 16
psi_16=np.array([-0.9894009, -0.9445750, -0.8656312, -0.7554044, -0.6178762, \
-0.4580168, -0.2816036, -0.0950125, 0.0950125, 0.2816036, \
0.4580168, 0.6178762, 0.7554044, 0.8656312, 0.9445750, \
0.9894009])
w_16 =np.array([ 0.0271525, 0.0622535, 0.0951585, 0.1246290, 0.1495960, \
0.1691565, 0.1826034, 0.1894506, 0.1894506, 0.1826034, \
0.1691565, 0.1495960, 0.1246290, 0.0951585, 0.0622535, \
0.0271525])
y = np.zeros(nPoints_GK)
yIntegrated = 0.
for n in range(nPoints_GK):
xCrrnt = psi_16[n]*(xMax-xMin)/2 + (xMax+xMin)/2.
factorA = math.pow(10.,fitA)
y[n] = factorA*math.pow(xCrrnt,fitB)
yIntegrated += (xMax-xMin)*w_16[n]*y[n]*xCrrnt
return y,yIntegrated
#------------------ End of defined functions -----------------------
#
#====================================================================
sphereNe=3.
R_e=math.pow(sphereNe/n_e,1./3) # cm
print ('R_e (cm)=%e' % R_e)
ro_Larm = eVrmsTran/omega_L # cm
print ('ro_Larm (cm)=%e' % ro_Larm)
impctPrmtrMin=2.*ro_Larm
# rhoDependenceFlag = 1 # skip calculation of rho dependence if = 0!
#============ Important flags ===========================
#
# Taking into account the transfer of momenta for both particles
# (for "classical" only):
dpTransferFlag = 1 # no taking into account if = 0!
#
saveFilesFlag = 0 # no saving if = 0!
#
plotFigureFlag = 1 # plot if = 1!
#
#========================================================
nVion=50
Vion=np.zeros(nVion)
VionLong=np.zeros(nVion)
VionTrnsv=np.zeros(nVion)
VionRel=np.zeros(nVion)
vIonMin=4.e-3*eVrmsTran
vIonMax=10.*eVrmsTran
vIonMinRel=vIonMin/V0
vIonMaxRel=vIonMax/V0
print ('VionMin=%e (vIonMinRel=%e), vIonMax=%e (vIonMaxRel=%e)' % \
(vIonMin,vIonMinRel,vIonMax,vIonMaxRel))
vIonLogStep=math.log10(vIonMax/vIonMin)/(nVion-1)
R_debye=np.zeros(nVion)
R_pass=np.zeros(nVion)
R_pass_1=np.zeros(nVion) # for longT=0. --> eVrmsLong=0.
impctPrmtrMax=np.zeros(nVion)
impctPrmtrMax_1=np.zeros(nVion) # for longT=0. --> eVrmsLong=0.
for i in range(nVion):
crrntLogVionRel=math.log10(vIonMinRel)+i*vIonLogStep
VionRel[i]=math.pow(10.,crrntLogVionRel)
Vion[i]=VionRel[i]*V0
VionLong[i]=Vion[i]*np.cos(thetaVi)
VionTrnsv[i]=Vion[i]*np.sin(thetaVi)
R_debye[i]=np.sqrt(Vion[i]**2+eVrmsTran**2+eVrmsLong**2)/omega_p
R_pass[i]=np.sqrt(Vion[i]**2+eVrmsLong**2)*coolPassTime
R_pass_1[i]=np.sqrt(Vion[i]**2+0.*eVrmsLong**2)*coolPassTime
help=max(R_debye[i],R_e)
impctPrmtrMax[i]=min(help,R_pass[i])
impctPrmtrMax_1[i]=min(help,R_pass_1[i])
#-----------------------------------------------------------------
# Checking of corection of the maximal impact parameter on depence
# of preset number of minimal Larmor turns
#
larmorTurnsMin=[10,20,30,40]
impctPrmtrMaxCrrctd=np.zeros((nVion,4))
impctPrmtrMaxCrrctdRel=np.zeros((nVion,4))
for n in range (4):
for i in range(nVion):
impctPrmtrMaxCrrctd[i,n]=impctPrmtrMax[i]* \
np.sqrt(1.- (pi*larmorTurnsMin[n]*eVrmsLong/omega_L/impctPrmtrMax[i])**2)
impctPrmtrMaxCrrctdRel[i,n]=impctPrmtrMaxCrrctd[i,n]/impctPrmtrMax[i]
#
# First plotting:
#
if (plotFigureFlag == 0):
fig10 = plt.figure(10)
plt.semilogx(impctPrmtrMax,impctPrmtrMaxCrrctdRel[:,0],'-r', \
impctPrmtrMax,impctPrmtrMaxCrrctdRel[:,1],'-b', \
impctPrmtrMax,impctPrmtrMaxCrrctdRel[:,2],'-g', \
impctPrmtrMax,impctPrmtrMaxCrrctdRel[:,3],'-m',linewidth=2)
plt.grid(True)
hold=True
plt.xlabel('Maximal Impact parameter $R_{max}$, cm',color='m',fontsize=16)
plt.ylabel('$R_{max}^{Crrctd}/R_{Max}$',color='m',fontsize=16)
# plt.xlim([.9*min(impctPrmtrMax),1.1*max(impctPrmtrMax)])
plt.xlim([1.e-2,1.1*max(impctPrmtrMax)])
plt.ylim([.986,1.001])
titleHeader='$R_{max}^{Crrctd}=R_{Max} \cdot [1-(\pi\cdot N_{Larm} \cdot'
titleHeader += '\Delta_{e||}/(\omega_{Larm} \cdot R_{max})]^{1/2}$'
plt.title(titleHeader,color='m',fontsize=16)
plt.legend([('$N_{Larm}=$%2d' % larmorTurnsMin[0]), \
('$N_{Larm}=$%2d' % larmorTurnsMin[1]), \
('$N_{Larm}=$%2d' % larmorTurnsMin[2]), \
('$N_{Larm}=$%2d' % larmorTurnsMin[3])],loc='lower center',fontsize=14)
if (saveFilesFlag == 1):
fig10.savefig('picturesCMA/correctedRmax_fig10cma.png')
print ('File "picturesCMA/correctedRmax_fig10cma.png" is written')
xLimit=[.9*VionRel[0],1.1*VionRel[nVion-1]]
#
# Typs of collisions:
#
if (plotFigureFlag == 0):
fig3151=plt.figure (3151)
plt.loglog(VionRel,impctPrmtrMax,'-r', VionRel,impctPrmtrMax_1,'--r', \
[VionRel[0],VionRel[nVion-1]],[impctPrmtrMin,impctPrmtrMin],'-b',linewidth=2)
plt.grid(True)
hold=True
plt.xlabel('Relative Ion Velocity, $V_i/V_{e0}$',color='m',fontsize=14)
plt.ylabel('Impact Parameter, cm',color='m',fontsize=14)
titleHeader= \
'Types of Collisions: $V_{e0}=%4.2f\cdot10^{%2d}$ cm/s, $B=%6.1f$ Gs'
plt.title(titleHeader % (mantV0,powV0,fieldB[0]),color='m',fontsize=16)
plt.xlim(xLimit)
yLimit=[8.e-4,.6]
plt.ylim(yLimit)
plt.plot([relVeTrnsv,relVeTrnsv],yLimit,'--m',linewidth=1)
plt.text(1.6e-3,5.e-4,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([relVeLong,relVeLong],yLimit,'--m',linewidth=1)
plt.text(4.4e-5,.0018,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
plt.text(3.e-4,1.75e-3,'$R_{min}=2\cdot<rho_\perp>$',color='k',fontsize=16)
plt.text(7.e-4,5.e-2,'$R_{max}$',color='k',fontsize=16)
plt.text(2.85e-5,3.3e-3,'$R_{max}$ $for$ $T_{e||}=0$',color='k',fontsize=16)
plt.plot([VionRel[0],VionRel[nVion-1]],[20.*rhoCrit,20.*rhoCrit],color='k')
plt.text(1.e-4,7.e-3,'Magnetized Collisions',color='r',fontsize=20)
plt.text(1.e-4,10.e-4,'Adiabatic or Fast Collisions',color='r',fontsize=20)
plt.text(2.25e-5,.275,'Collisions are Screened',color='r',fontsize=20)
plt.text(1.6e-5,1.e-3,'$ \cong 20\cdot R_{Crit}$',color='k',fontsize=16)
if (saveFilesFlag == 1):
fig3151.savefig('picturesCMA_v7/impctPrmtr_fig3151cma.png')
print ('File "picturesCMA_v7/impctPrmtr_fig3151cma.png" is written')
#
# Picture for HESR:
#
if (plotFigureFlag == 0):
fig3151=plt.figure (3151)
plt.loglog(VionRel,impctPrmtrMax,'-r', VionRel,impctPrmtrMax_1,'--r', \
[VionRel[0],VionRel[nVion-1]],[impctPrmtrMin,impctPrmtrMin],'-b',linewidth=2)
plt.grid(True)
hold=True
plt.xlabel('Relative Ion Velocity, $V_i/V_{e0}$',color='m',fontsize=14)
plt.ylabel('Impact Parameter, cm',color='m',fontsize=14)
titleHeader= \
'HESR Types of Collisions: $V_{e0}=%3.1f\cdot10^{%2d}$cm/s, $B=%3.1f$T'
plt.title(titleHeader % (mantV0,powV0,1.e-4*fieldB[0]),color='m',fontsize=16)
plt.xlim(xLimit)
yLimit=[8.e-4,.6]
plt.ylim(yLimit)
plt.plot([relVeTrnsv,relVeTrnsv],yLimit,'--m',linewidth=1)
plt.text(4.4e-4,8.4e-4,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([relVeLong,relVeLong],yLimit,'--m',linewidth=1)
plt.text(1.e-4,8.4e-4,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
plt.text(3.7e-6,3.4e-3,'$R_{min}=2\cdot<rho_\perp>$',color='b',fontsize=16)
plt.text(2.8e-4,.1,'$R_{max}$',color='k',fontsize=16)
plt.text(1.e-4,1.8e-2,'$R_{max}$ $for$ $T_{e||}=0$',color='k',fontsize=16)
plt.plot([VionRel[0],VionRel[nVion-1]],[20.*rhoCrit,20.*rhoCrit],color='k')
plt.text(6.8e-5,7.e-3,'Magnetized Collisions',color='r',fontsize=20)
plt.text(6.8e-5,1.2e-3,'Weak Collisions',color='r',fontsize=20)
plt.text(2.3e-5,1.95e-3,'Adiabatic or Fast Collisions',color='r',fontsize=20)
plt.text(2.e-5,.275,'Screened Collisions',color='r',fontsize=20)
plt.text(3.58e-6,2.05e-3,'$\cong$20$\cdot$$R_{Crit}$',color='k',fontsize=16)
if (saveFilesFlag == 1):
# fig3151.savefig('picturesCMA_v7/impctPrmtr_fig3151cma.png')
# print ('File "picturesCMA_v7/impctPrmtr_fig3151cma.png" is written')
fig3151.savefig('HESRimpctPrmtr_fig3151cma.png')
print ('File "HESRimpctPrmtr_fig3151cma.png" is written')
#
# Picture for EIC:
#
if (plotFigureFlag == 0):
fig3151=plt.figure (3151)
plt.loglog(VionRel,impctPrmtrMax,'-r', VionRel,impctPrmtrMax_1,'--r', \
[VionRel[0],VionRel[nVion-1]],[impctPrmtrMin,impctPrmtrMin],'-b',linewidth=2)
plt.grid(True)
hold=True
plt.xlabel('Relative Ion Velocity, $V_i/V_{e0}$',color='m',fontsize=14)
plt.ylabel('Impact Parameter, cm',color='m',fontsize=14)
titleHeader= \
'EIC Types of Collisions: $V_{e0}=%3.1f\cdot10^{%2d}$cm/s, $B=%3.1f$T'
plt.title(titleHeader % (mantV0,powV0,1.e-4*fieldB[0]),color='m',fontsize=16)
plt.xlim(xLimit)
yLimit=[5.e-5,.3]
plt.ylim(yLimit)
plt.plot([relVeTrnsv,relVeTrnsv],yLimit,'--m',linewidth=1)
plt.text(9.e-4,4.e-5,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([relVeLong,relVeLong],yLimit,'--m',linewidth=1)
plt.text(1.7e-4,3.e-5,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
plt.text(6.3e-6,1.1e-4,'$R_{min}=2\cdot<rho_\perp>$',color='b',fontsize=16)
plt.text(1.e-4,2.1e-2,'$R_{max}$',color='k',fontsize=16)
plt.text(2.57e-5,5.e-3,'$R_{max}$ $for$ $T_{e||}=0$',color='k',fontsize=16)
plt.plot([VionRel[0],VionRel[nVion-1]],[20.*rhoCrit,20.*rhoCrit],color='k')
plt.text(2.3e-5,1.e-3,'Magnetized Collisions',color='r',fontsize=20)
# plt.text(6.8e-5,1.2e-3,'Weak Collisions',color='r',fontsize=20)
plt.text(1.1e-5,5.7e-5,'Weak or Adiabatic or Fast Collisions',color='r',fontsize=16)
plt.text(2.e-5,.15,'Screened Collisions',color='r',fontsize=20)
plt.text(2.5e-3,1.7e-4,'$\cong$20$\cdot$$R_{Crit}$',color='k',fontsize=16)
if (saveFilesFlag == 1):
# fig3151.savefig('picturesCMA_v7/impctPrmtr_fig3151cma.png')
# print ('File "picturesCMA_v7/impctPrmtr_fig3151cma.png" is written')
fig3151.savefig('EICimpctPrmtr_fig3151cma.png')
print ('File "EICimpctPrmtr_fig3151cma.png" is written')
# plt.show()
# sys.exit()
#
# Magnetized collisions:
#
if (plotFigureFlag == 0):
fig209=plt.figure (209)
plt.loglog(VionRel,R_debye,'-r',VionRel,R_pass,'-b', \
VionRel,R_pass_1,'--b',linewidth=2)
plt.grid(True)
hold=True
plt.plot([VionRel[0],VionRel[nVion-1]],[R_e,R_e],color='m',linewidth=2)
plt.xlabel('Relative Ion Velocity, $V_i/V_{e0}$',color='m',fontsize=16)
plt.ylabel('$R_{Debye}$, $R_{Pass}$, $R_e$, cm',color='m',fontsize=16)
# titleHeader='Magnetized Collision: $R_{Debye}$, $R_{Pass}$, $R_e$: $V_{e0}=%5.3f\cdot10^{%2d}$cm/s'
# plt.title(titleHeader % (mantV0,powV0),color='m',fontsize=16)
plt.title('Magnetized Collisions: $R_{Debye}$, $R_{Pass}$, $R_e$',color='m',fontsize=16)
plt.xlim(xLimit)
yLimit=[1.e-3,10.]
plt.ylim(yLimit)
plt.plot([relVeTrnsv,relVeTrnsv],yLimit,'--m',linewidth=1)
plt.text(1.6e-3,5.5e-4,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([relVeLong,relVeLong],yLimit,'--m',linewidth=1)
plt.text(4.4e-5,0.001175,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
plt.text(3.e-5,2.45e-3,'$R_e$',color='k',fontsize=16)
plt.text(3.e-5,5.e-2,'$R_{Debye}$',color='k',fontsize=16)
plt.text(3.e-5,1.8e-2,'$R_{Pass}$',color='k',fontsize=16)
plt.text(4.5e-5,4.8e-3,'$R_{Pass}$ $for$ $T_{e||}=0$',color='k',fontsize=16)
plt.text(8.3e-5,4.0,('$V_{e0}=%5.3f\cdot10^{%2d}$cm/s' % (mantV0,powV0)), \
color='m',fontsize=16)
if (saveFilesFlag == 1):
fig209.savefig('picturesCMA/rDebye_rLikeDebye_rPass_fig209cma.png')
print ('File "picturesCMA/rDebye_rLikeDebye_rPass_fig209cma.png" is written')
#
# Coulomb logarithm evaluation:
#
clmbLog = np.zeros(nVion)
for i in range(nVion):
clmbLog[i] = math.log(impctPrmtrMax[i]/impctPrmtrMin)
# clmbLog[i] = math.log(impctPrmtrMax_1[i]/impctPrmtrMin)
if (plotFigureFlag == 0):
fig3155=plt.figure (3155)
plt.semilogx(VionRel,clmbLog,'-xr',linewidth=2)
plt.xlabel('Relative Ion Velocity, $V_i/V_{e0}$',color='m',fontsize=14)
plt.ylabel('Coulomb Logarithm $L_c$',color='m',fontsize=14)
plt.title('Coulomb Logarithm: $L_c$ = $ln(R_{max}/R_{min})$',color='m',fontsize=16)
yLimit=[min(clmbLog)-.1,max(clmbLog)+.1]
plt.ylim(yLimit)
plt.plot([relVeTrnsv,relVeTrnsv],yLimit,'--m',linewidth=1)
plt.text(1.6e-3,5.,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([relVeLong,relVeLong],yLimit,'--m',linewidth=1)
plt.text(3.4e-5,5.,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
if (saveFilesFlag == 1):
fig3155.savefig('picturesCMA_v7/coulombLogrthm_fig3155cma.png')
print ('File "picturesCMA_v7/coulombLogrthm_fig3155cma.png" is written')
#
# matrix for electron with .5*timeStep_c:
#
matr_elec_c=guidingCenter_Matrix(.5*timeStep_c)
#
# matrix for ion with mass M_ion and .5*timeStep_c:
#
matr_ion_c=drift_Matrix(M_ion,.5*timeStep_c)
larmorTurns = 10
nImpctPrmtr = 50
rhoMin = impctPrmtrMin
rhoMax = np.zeros(nVion)
log10rhoMin = math.log10(rhoMin)
crrntImpctPrmtr = np.zeros(nImpctPrmtr)
halfLintr = np.zeros((nImpctPrmtr,nVion))
pointAlongTrack = np.zeros((nImpctPrmtr,nVion))
totalPoints = 0
for i in range(nVion):
rhoMax[i] = impctPrmtrMax[i]* \
np.sqrt(1.- (pi*larmorTurns*eVrmsLong/omega_L/impctPrmtrMax[i])**2)
rhoMax[i] = impctPrmtrMax[i]
# rhoMax[i] = impctPrmtrMax_1[i] # for checking!
# print ('rhoMax(%d) = %e' % (i,rhoMax[i]))
log10rhoMax = math.log10(rhoMax[i])
log10rhoStep = (log10rhoMax-log10rhoMin)/(nImpctPrmtr)
# print ('Vion(%d) = %e, rhoMax = %e' % (i,Vion[i],rhoMax[i]))
for n in range(nImpctPrmtr):
log10rhoCrrnt = log10rhoMin+(n+0.5)*log10rhoStep
rhoCrrnt = math.pow(10.,log10rhoCrrnt)
# print (' rhoCrrnt(%d) = %e' % (n,rhoCrrnt))
halfLintr[n,i] = np.sqrt(rhoMax[i]**2-rhoCrrnt**2) # half length of interaction; cm
timeHalfPath = halfLintr[n,i]/eVrmsLong # 0.5 time of interaction; sec
numbLarmor = int(2.*timeHalfPath/T_larm)
pointAlongTrack[n,i] = int(2.*timeHalfPath/timeStep_c)
totalPoints += pointAlongTrack[n,i]
# print (' %d: rhoCrrnt = %e, numbLarmor = %d, pointAlongTrack = %d' % \
# (n,rhoCrrnt,numbLarmor,pointAlongTrack[n,i]))
# print ('totalPoints = %d' % totalPoints)
totalPoints = int(totalPoints)
nnTotalPoints=np.arange(0,2*totalPoints-1,1)
arrayA=np.zeros(2*totalPoints)
arrayB=np.zeros(2*totalPoints)
bCrrnt_c = np.zeros(2*totalPoints)
#
# Variables for different testing:
#
b_gc = np.zeros(totalPoints)
action_gc = np.zeros(totalPoints)
C1test = np.zeros(totalPoints)
C2test = np.zeros(totalPoints)
C3test = np.zeros(totalPoints)
b_ME = np.zeros(totalPoints)
D1test = np.zeros(totalPoints)
D2test = np.zeros(totalPoints)
qTest = np.zeros(totalPoints)
action_ME = np.zeros(totalPoints)
actn_gc_ME_rel = np.zeros(totalPoints)
indxTest = 0
rhoInit = np.zeros((nImpctPrmtr,nVion))
#
# "Classical" approach:
#
deltaPx_c = np.zeros((nImpctPrmtr,nVion))
deltaPy_c = np.zeros((nImpctPrmtr,nVion))
deltaPz_c = np.zeros((nImpctPrmtr,nVion))
ionVx_c = np.zeros((nImpctPrmtr,nVion))
ionVy_c = np.zeros((nImpctPrmtr,nVion))
ionVz_c = np.zeros((nImpctPrmtr,nVion))
deltaEnrgIon_c = np.zeros((nImpctPrmtr,nVion))
#
# "Magnus Expand" approach:
#
deltaPx_m = np.zeros((nImpctPrmtr,nVion))
deltaPy_m = np.zeros((nImpctPrmtr,nVion))
deltaPz_m = np.zeros((nImpctPrmtr,nVion))
ionVx_m = np.zeros((nImpctPrmtr,nVion))
ionVy_m = np.zeros((nImpctPrmtr,nVion))
ionVz_m = np.zeros((nImpctPrmtr,nVion))
deltaEnrgIon_m = np.zeros((nImpctPrmtr,nVion))
#
# Comparison of approaches (ratio deltaEnrgIon_c/deltaEnrgIon_m):
#
deltaPx_c_m = np.zeros((nImpctPrmtr,nVion))
deltaPy_c_m = np.zeros((nImpctPrmtr,nVion))
deltaPz_c_m = np.zeros((nImpctPrmtr,nVion))
dEion_c_m = np.zeros((nImpctPrmtr,nVion))
#
# Factor to calculate transferred energy to ion
# (the friction force is defined by this transfered energy):
#
deFactor = 0.5/M_ion # 1/g
frctnForce_cSM = np.zeros(nVion) # integration, using Simpson method
frctnForce_mSM = np.zeros(nVion) # integration, using Simpson method
numberWrongSign_c=0
numberWrongSign_m=0
posSignDeltaEnrgIon_c=0
negSignDeltaEnrgIon_c=0
posSignDeltaEnrgIon_m=0
negSignDeltaEnrgIon_m=0
timeRun = np.zeros(nVion)
totalTimeRun = 0.
indx = 0
# ----------------- Main simulation ---------------
#
for i in range(nVion):
# Taking into account the corection of the maximal impact parameter
# on depence of preset number of minimal Larmor turns:
rhoMax[i] = impctPrmtrMax[i]* \
np.sqrt(1.- (pi*larmorTurns*eVrmsLong/omega_L/impctPrmtrMax[i])**2)
# Without taking into account the corection of the maximal impact parameter
# on depence of preset number of minimal Larmor turns:
rhoMax[i] = impctPrmtrMax[i]
# rhoMax[i] = impctPrmtrMax_1[i] # for checking!
log10rhoMax = math.log10(rhoMax[i])
log10rhoStep = (log10rhoMax-log10rhoMin)/(nImpctPrmtr)
# print ('Vion(%d) = %e, rhoMax = %e' % (i,Vion[i],rhoMax[i]))
timeStart=os.times()
for n in range(nImpctPrmtr):
log10rhoCrrnt = log10rhoMin+(n+0.5)*log10rhoStep
rhoCrrnt = math.pow(10.,log10rhoCrrnt)
# rhoInit[i*nImpctPrmtr+n] = rhoCrrnt
rhoInit[n,i] = rhoCrrnt
halfLintr[n,i] = np.sqrt(rhoMax[i]**2-rhoCrrnt**2) # half length of interaction; cm
z_ionCrrnt_c = np.zeros(6) # Zeroing out of vector for ion ("GC"-approach)
z_elecCrrnt_c = np.zeros(6) # Zeroing out of vector for electron ("GC"-approach)
z_ionCrrnt_m = np.zeros(6) # Zeroing out of vector for ion ("ME"-approach)
z_elecCrrnt_m = np.zeros(6) # Zeroing out of vector for electron ("ME"-approach)
# Zeroing out of "guiding center" vector for electron (both approaches):
z_elecCrrnt_gc_c = np.zeros(6)
z_elecCrrnt_gc_m = np.zeros(6)
# Current values of transfered momemta
# (second index numerates "Guiding Center", (if 0) and
# "Magnus Expantion" (if 1) approaches:
dpCrrnt = np.zeros((3,2))
# Intermediate arrays:
dpIon_c = np.zeros(3)
dpIon_m = np.zeros(3)
dpElec_c = np.zeros(3)
dpElec_m = np.zeros(3)
# Current initial vector for electron:
z_elecCrrnt_c[Ix] = rhoCrrnt # x, cm
z_elecCrrnt_c[Iz] = -halfLintr[n,i] # z, cm
z_elecCrrnt_c[Ipy] = m_elec*eVrmsTran # py, g*cm/sec
z_elecCrrnt_c[Ipz] = m_elec*eVrmsLong # pz, g*cm/sec
z_elecCrrnt_m[Ix] = rhoCrrnt # x, cm
z_elecCrrnt_m[Iz] = -halfLintr[n,i] # z, cm
z_elecCrrnt_m[Ipy] = m_elec*eVrmsTran # py, g*cm/sec
z_elecCrrnt_m[Ipz] = m_elec*eVrmsLong # pz, g*cm/sec
# Current initial vector for ion velocity for both approaches:
ionVx_c[n,i] = VionTrnsv[i]*np.cos(phiVi)
ionVy_c[n,i] = VionTrnsv[i]*np.sin(phiVi)
ionVz_c[n,i] = VionLong[i]
ionVx_m[n,i] = VionTrnsv[i]*np.cos(phiVi)
ionVy_m[n,i] = VionTrnsv[i]*np.sin(phiVi)
ionVz_m[n,i] = VionLong[i]
# transfer to system of guiding center:
z_elecCrrnt_gc_c=toGuidingCenter(z_elecCrrnt_c)
z_elecCrrnt_gc_m=toGuidingCenter(z_elecCrrnt_m)
#
# Main loop along the each track:
#
for k in range(int(pointAlongTrack[n,i])):
#
# Dragging both particles through first half of the step of the track:
#
z_elecCrrnt_gc_c = np.dot(matr_elec_c,z_elecCrrnt_gc_c) # electron
z_elecCrrnt_gc_m = np.dot(matr_elec_c,z_elecCrrnt_gc_m) # electron
z_ionCrrnt_c = np.dot(matr_ion_c,z_ionCrrnt_c) # ion
z_ionCrrnt_m = np.dot(matr_ion_c,z_ionCrrnt_m) # ion
# transfer from system of guiding center:
z_elecCrrnt_c=fromGuidingCenter(z_elecCrrnt_gc_c)
z_elecCrrnt_m=fromGuidingCenter(z_elecCrrnt_gc_m)
# Current distance between ion and electron; cm:
bCrrnt_c[indx]=np.sqrt((z_ionCrrnt_c[0]-z_elecCrrnt_c[0])**2+ \
(z_ionCrrnt_c[2]-z_elecCrrnt_c[2])**2+ \
(z_ionCrrnt_c[4]-z_elecCrrnt_c[4])**2)
# Current values of parameters A,B:
arrayA[indx] = math.log10(ro_Larm/bCrrnt_c[indx])
arrayB[indx] = math.log10((q_elec**2/bCrrnt_c[indx])/kinEnergy)
indx += 1
#
# Dragging both particles through interaction during this step of track
# (for both approaches):
#
# "Guiding Center":
dpIon_c,dpElec_c,action,b_gc_c = \
guidingCenterCollision(z_elecCrrnt_gc_c,z_ionCrrnt_c,timeStep_c)
# "Magnus Expantion":
dpIon_m,dpElec_m,actionME,dy_gc_m,C1,C2,C3,b,D1,D2,q = \
MagnusExpansionCollision(z_elecCrrnt_gc_m,z_ionCrrnt_m,timeStep_c)
# Save data for testing:
b_gc[indxTest] = b_gc_c # "Guiding Center" approach
action_gc[indxTest] = action # -"- -"- -"- -"- -"- -"-
C1test[indxTest] = C1 # "Magnus expansion" approach
C2test[indxTest] = abs(C2) # -"- -"- -"- -"- -"- -"-
C3test[indxTest] = C3 # -"- -"- -"- -"- -"- -"-
b_ME[indxTest] = b # -"- -"- -"- -"- -"- -"-
D1test[indxTest] = D1 # -"- -"- -"- -"- -"- -"-
D2test[indxTest] = D2 # -"- -"- -"- -"- -"- -"-
qTest[indxTest] = q #-"- -"- -"- -"- -"- -"-
action_ME[indxTest] = actionME #-"- -"- -"- -"- -"- -"-
indxTest += 1
indxTestMax = indxTest
#
# Taking into account transfer of momentum for both particles:
#
if (dpTransferFlag == 1):
for ic in range(3):
z_ionCrrnt_c[2*ic+1] += dpIon_c[ic]
z_elecCrrnt_c[2*ic+1] += dpElec_c[ic]
z_ionCrrnt_m[2*ic+1] += dpIon_m[ic]
z_elecCrrnt_m[2*ic+1] += dpElec_m[ic]
# transfer to system of guiding center:
z_elecCrrnt_gc_c=toGuidingCenter(z_elecCrrnt_c)
z_elecCrrnt_gc_m=toGuidingCenter(z_elecCrrnt_m)
# Accumulation of the transfered momenta to ion along the track for both approaches:
for ic in range(3):
# if i == 0:
# print ('dpIon_c[%2d] = %20.14e, dpIon_m[%2d] = %20.14e' % \
# (ic,dpIon_c[ic],ic,dpIon_m[ic]))
dpCrrnt[ic,0] += dpIon_c[ic] # "Guiding Center", g*cm/sec
dpCrrnt[ic,1] += dpIon_m[ic] # "Magnus Expansion", g*cm/sec
#
# Ion's elocity change along the track - both approaches:
#
ionVx_c[n,i] += dpCrrnt[0,0]/M_ion # cm/sec
ionVy_c[n,i] += dpCrrnt[1,0]/M_ion # cm/sec
ionVz_c[n,i] += dpCrrnt[2,0]/M_ion # cm/sec
ionVx_m[n,i] += dpCrrnt[0,1]/M_ion # cm/sec
ionVy_m[n,i] += dpCrrnt[1,1]/M_ion # cm/sec
ionVz_m[n,i] += dpCrrnt[2,1]/M_ion # cm/sec
#
# Dragging both particles through second half of the step of the track:
#
z_elecCrrnt_gc_c = np.dot(matr_elec_c,z_elecCrrnt_gc_c) # electron
z_ionCrrnt_c = np.dot(matr_ion_c,z_ionCrrnt_c) # ion
z_elecCrrnt_gc_m = np.dot(matr_elec_c,z_elecCrrnt_gc_m) # electron
z_ionCrrnt_m = np.dot(matr_ion_c,z_ionCrrnt_m) # ion
# transfer from system of guiding center:
z_elecCrrnt_c=fromGuidingCenter(z_elecCrrnt_gc_c)
z_elecCrrnt_m=fromGuidingCenter(z_elecCrrnt_gc_m)
# Current distance between ion and electron; cm:
bCrrnt_c[indx]=np.sqrt((z_ionCrrnt_c[0]-z_elecCrrnt_c[0])**2+ \
(z_ionCrrnt_c[2]-z_elecCrrnt_c[2])**2+ \
(z_ionCrrnt_c[4]-z_elecCrrnt_c[4])**2)
# Current values of parameters A,B:
arrayA[indx] = math.log10(ro_Larm/bCrrnt_c[indx])
arrayB[indx] = math.log10((q_elec**2/bCrrnt_c[indx])/kinEnergy)
indx += 1
#
# Transferred momenta along the track - "Guiding Center" approach:
#
deltaPx_c[n,i] = dpCrrnt[0,0] # dpx, g*cm/sec
# if deltaPx_c[n,i] <= 0.:
# print ('deltaPx_c[%2d,%2d] = %e, dpCrrnt[%2d,%2d] = %e' % \
# (n,i,deltaPx_c[n,i],n,i,dpCrrnt[0,0]))
deltaPy_c[n,i] = dpCrrnt[1,0] # dpy, g*cm/sec
# if deltaPy_c[n,i] <= 0.:
# print ('deltaPy_c[%2d,%2d] = %e' % (n,i,deltaPy_c[n,i]))
deltaPz_c[n,i] = dpCrrnt[2,0] # dpz, g*cm/sec
# if deltaPz_c[n,i] <= 0.:
# print ('deltaPz_c[%2d,%2d] = %e' % (n,i,deltaPz_c[n,i]))
# Incorrect value:
# deltaEnrgIon_c[n,i] = (dpCrrnt[0,0]**2+dpCrrnt[1,0]**2+dpCrrnt[2,0]**2)* \
# deFactor/eVtoErg # eV
# Correct value:
crrntDeltaEnrg = (dpCrrnt[0,0]*ionVx_c[n,i]+ \
dpCrrnt[1,0]*ionVy_c[n,i]+ \
dpCrrnt[2,0]*ionVz_c[n,i])*deFactor/eVtoErg # eV
absDeltaEnrgIon_c = abs(crrntDeltaEnrg)
if (crrntDeltaEnrg != 0.):
signDeltaEnrgIon_c = crrntDeltaEnrg/abs(crrntDeltaEnrg)
deltaEnrgIon_c[n,i] = crrntDeltaEnrg
if (deltaEnrgIon_c[n,i] > 0.):
posSignDeltaEnrgIon_c += 1
else:
negSignDeltaEnrgIon_c += 1
#
# Transferred momenta along the track - "Magnus expansion" approach:
#
deltaPx_m[n,i] = dpCrrnt[0,1] # dpx, g*cm/sec
# if deltaPx_m[n,i] <= 0.:
# print ('deltaPx_m[%2d,%2d] = %e' % (n,i,deltaPx_m[n,i]))
deltaPy_m[n,i] = dpCrrnt[1,1]
# if deltaPy_m[n,i] <= 0.:
# print ('deltaPy_m[%2d,%2d] = %e' % (n,i,deltaPy_m[n,i]))
deltaPz_m[n,i] = dpCrrnt[2,1]
# if deltaPz_m[n,i] <= 0.:
# print ('deltaPz_m[%2d,%2d] = %e' % (n,i,deltaPz_m[n,i]))
# Incorrect value:
# deltaEnrgIon_m[n,i] = (dpCrrnt[0,1]**2+dpCrrnt[1,1]**2+dpCrrnt[2,1]**2)* \
# deFactor/eVtoErg # eV
# Correct value absolute value):
crrntDeltaEnrg = (dpCrrnt[0,1]*ionVx_m[n,i]+ \
dpCrrnt[1,1]*ionVy_m[n,i]+ \
dpCrrnt[2,1]*ionVz_m[n,i])*deFactor/eVtoErg # eV
absDeltaEnrgIon_m = abs(crrntDeltaEnrg)
if (crrntDeltaEnrg != 0.):
signDeltaEnrgIon_m = crrntDeltaEnrg/abs(crrntDeltaEnrg)
deltaEnrgIon_m[n,i] = crrntDeltaEnrg
if (deltaEnrgIon_m[n,i] > 0.):
posSignDeltaEnrgIon_m += 1
else:
negSignDeltaEnrgIon_m += 1
#
# Comparison of the approaches (%):
#
if (deltaPx_m[n,i] != 0.):
deltaPx_c_m[n,i] = 100.*(deltaPx_c[n,i]/deltaPx_m[n,i]-1.)
else:
print ('Bad value (=0.) of deltaPx_m[%d,%d] = ' % (n,i))
if (deltaPy_m[n,i] != 0.):
deltaPy_c_m[n,i] = 100.*(deltaPy_c[n,i]/deltaPy_m[n,i]-1.)
else:
print ('Bad value (=0.) of deltaPy_m[%d,%d] = ' % (n,i))
if (deltaPz_m[n,i] != 0.):
deltaPz_c_m[n,i] = 100.*(deltaPz_c[n,i]/deltaPz_m[n,i]-1.)
else:
print ('Bad value (=0.) of deltaPz_m[%d,%d] = ' % (n,i))
if (deltaEnrgIon_m[n,i] != 0.):
dEion_c_m[n,i] = 100.*(deltaEnrgIon_c[n,i]/deltaEnrgIon_m[n,i]-1.)
else:
print ('Bad value (=0.) of deltaEnrgIon_m[%d,%d] = ' % (n,i))
#
# Integration using Simpson method:
#
if (n > 0):
frctnForce_cSM[i] += pi*n_e*100.*(deltaEnrgIon_c[n,i]+deltaEnrgIon_c[n-1,i])* \
.5*(rhoInit[n,i]+rhoInit[n-1,i])* \
(rhoInit[n,i]-rhoInit[n-1,i]) # eV/m
frctnForce_mSM[i] += pi*n_e*100.*(deltaEnrgIon_m[n,i]+deltaEnrgIon_m[n-1,i])* \
.5*(rhoInit[n,i]+rhoInit[n-1,i])* \
(rhoInit[n,i]-rhoInit[n-1,i]) # eV/m
timeEnd = os.times()
timeRun[i] = float(timeEnd[0])-float(timeStart[0]) # CPU time , sec
totalTimeRun += timeRun[i]
print ('timeRun(%2d) = %6.3f seconds' % (i,timeRun[i]))
print ('Total time (icluding Simpson integration) = %6.3f seconds' % totalTimeRun)
print ('deltaEnrgIon_c: nPos=%d, nNeg=%d; deltaEnrgIon_m: nPos=%d, nNeg=%d' % \
(posSignDeltaEnrgIon_c,negSignDeltaEnrgIon_c, \
posSignDeltaEnrgIon_m,negSignDeltaEnrgIon_m))
#
# Output for checking:
#
# print \
# ('n Px_c Px_m Py_c Py_m Pz_c Pz_m Pz_c_m')
# for i in range(10,11,1):
# for n in range(nImpctPrmtr):
# print ('%d: %e %e %e %e %e %e %e' % \
# (n,deltaPx_c[n,i],deltaPx_m[n,i],deltaPy_c[n,i], \
# deltaPy_m[n,i],deltaPz_c[n,i],deltaPz_m[n,i],deltaPz_c_m[n,i]))
# print ('n dEion_c dEion_m')
# for i in range(10,11,1):
# for n in range(nImpctPrmtr):
# print ('%d: %e %e ' % (n,deltaEnrgIon_c[n,i],deltaEnrgIon_m[n,i]))
# print ('indxTestMax = %d' % indxTestMax)
#
# Plotting of the tests:
#
nn=np.arange(0,indxTestMax-1,1)
#
# C1:
#
if (plotFigureFlag == 0):
fig2020=plt.figure (2020)
plt.plot(nn,C1test[0:indxTestMax-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$C1$, $cm^2$',color='m',fontsize=16)
plt.title('$C1=[x_{gc}^2+y_{gc}^2+z_e^2+2J/(m_e \cdot \Omega_e)]^{0.5}$', \
color='m',fontsize=16)
plt.xlim([-5000,indxTestMax+5000])
plt.grid(True)
if (saveFilesFlag == 1):
fig2020.savefig('picturesCMA_v7/magnusExpansion_C1_fig2020cma.png')
print ('File "picturesCMA_v7/magnusExpansion_C1_fig2020cma.png" is written')
#
# C2:
#
if (plotFigureFlag == 0):
fig2030=plt.figure (2030)
plt.plot(nn,1.e-5*C2test[0:indxTestMax-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$C2$, $\cdot 10^5$ $cm^2/s$',color='m',fontsize=16)
plt.title('$C2=2\cdot[V_{ix}\cdot(x_i-x_{gc})+V_{iy}\cdot(y_i-y_{gc})+(V_{iz}-V_{ez})\cdot(z_i-z_e)]$', \
color='m',fontsize=14)
plt.xlim([-5000,indxTestMax+5000])
plt.grid(True)
if (saveFilesFlag == 1):
fig2030.savefig('picturesCMA_v7/magnusExpansion_C2_fig2030cma.png')
print ('File "picturesCMA_v7/magnusExpansion_C2_fig2030cma.png" is written')
#
# C3:
#
if (plotFigureFlag == 0):
fig2040=plt.figure (2040)
plt.plot(nn,1e-11*C3test[0:indxTestMax-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$C3$, $\cdot 10^{11}$ $cm^2/s^2$',color='m',fontsize=16)
plt.title('$C3=V_{ix}^2+V_{iy}^2+(V_{iz}-V_{ez})^2$',color='m',fontsize=16)
plt.xlim([-5000,indxTestMax+5000])
plt.grid(True)
if (saveFilesFlag == 1):
fig2040.savefig('picturesCMA_v7/magnusExpansion_C3_fig2040cma.png')
print ('File "picturesCMA_v7/magnusExpansion_C3_fig2040cma.png" is written')
#
# D1:
#
if (plotFigureFlag == 0):
fig2025=plt.figure (2025)
plt.plot(nn,1.e-5*D1test[0:indxTestMax-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$10^{-5}\cdot D1$, $cm/s$',color='m',fontsize=16)
plt.title('$D1=(2C_3\cdot \Delta t+C_2)/b_{ME}$ $-$ $C_2/C_1^{0.5}$',color='m',fontsize=16)
plt.xlim([-5000,indxTestMax+5000])
plt.grid(True)
if (saveFilesFlag == 1):
fig2025.savefig('picturesCMA_v7/magnusExpansion_D1_fig2025cma.png')
print ('File "picturesCMA_v7/magnusExpansion_D1_fig2025cma.png" is written')
#
# D2:
#
if (plotFigureFlag == 0):
fig2035=plt.figure (2035)
plt.plot(nn,1.e4*D2test[0:indxTestMax-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$10^4\cdot D2$, $cm$',color='m',fontsize=16)
plt.title('$D2=(2C_1+C_2\cdot \Delta t)/b_{ME}$ $-$ $2C_1^{0.5}$',color='m',fontsize=16)
plt.xlim([-5000,indxTestMax+5000])
plt.grid(True)
if (saveFilesFlag == 1):
fig2035.savefig('picturesCMA_v7/magnusExpansion_D2_fig2035cma.png')
print ('File "picturesCMA_v7/magnusExpansion_D2_fig2035cma.png" is written')
#
# Distance b_ME between particles for "ME" approach:
#
if (plotFigureFlag == 0):
fig2050=plt.figure (2050)
plt.plot(nn,b_ME[0:indxTestMax-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$b_{ME}$, $cm$',color='m',fontsize=16)
plt.title('Distance $b_{ME}$ between Particles for "ME" Approach', color='m',fontsize=16)
plt.text(3500,.4,'$b_{ME}=[C1+C2\cdot \Delta t +C3 \cdot \Delta t^2]^{0.5}$', \
color='m',fontsize=16)
plt.text(33000,.36,('$(\Delta t=%8.2e$ $s)$' % timeStep_c),color='m',fontsize=16)
plt.xlim([-5000,indxTestMax+5000])
plt.grid(True)
if (saveFilesFlag == 1):
fig2050.savefig('picturesCMA_v7/particleDistance_me_fig2050cma.png')
print ('File "picturesCMA_v7/particleDistance_me_fig2050cma.png" is written')
#
# Distance b_gc between particles for "GC" approach:
#
if (plotFigureFlag == 0):
fig2055=plt.figure (2055)
plt.plot(nn,b_gc[0:indxTestMax-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$b_{GC}$, $cm$',color='m',fontsize=16)
plt.title('Distance $b_{GC}$ between Particles for "GC" Approach', color='m',fontsize=16)
plt.text(0,.4,'$b_{GC}=[(x_i-x_{gc})^2+(y_i-y_{gc})^2+$',color='m',fontsize=16)
plt.text(55500,.36,'$+(z_i-z_e)^2+2J/(m_e \cdot \Omega_e)]^{0.5}$', \
color='m',fontsize=16)
plt.xlim([-5000,indxTestMax+5000])
plt.grid(True)
if (saveFilesFlag == 1):
fig2055.savefig('picturesCMA/particleDistance_gc_fig2055cma.png')
print ('File "picturesCMA/particleDistance_gc_fig2055cma.png" is written')
#
# Comparison of bCrrnt_c from "Guiding Center" with bTest from
# "Magnus expansion" approaches:
#
bCrrnt_cTest = np.zeros(indxTestMax)
bCrrnt_cTestRel = np.zeros(indxTestMax)
b_gc_ME_rel = np.zeros(indxTestMax)
for k in range(indxTestMax):
bCrrnt_cTest[k] = .5*(bCrrnt_c[2*k]+bCrrnt_c[2*k+1])
# bCrrnt_cTestRel[k] = bCrrnt_cTest[k]/b_ME[k]
b_gc_ME_rel[k] = b_gc[k]/b_ME[k]
actn_gc_ME_rel[k] = 1.e7*(action_gc[k]/action_ME[k]-1.)
if (plotFigureFlag == 0):
fig2060=plt.figure (2060)
# plt.semilogy(nn,bCrrnt_cTest[0:indxTestMax-1],'.r')
plt.plot(nn,bCrrnt_cTest[0:indxTestMax-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('Test $b_{crrntTest}$, $cm$',color='m',fontsize=16)
plt.title('Test $b_{crrntTest} = .5 \cdot [b_{crrnt}(k)+b_{crrnt}(k+1)]$',color='m', \
fontsize=16)
plt.xlim([-5000,indxTestMax+5000])
# plt.ylim([.9*min(bCrrnt_cTest),1.1*max(bCrrnt_cTest)])
plt.grid(True)
#
# Ratio b_gc/b_ME (absolute value):
#
if (plotFigureFlag == 0):
fig2070=plt.figure (2070)
# plt.semilogy(nn,b_gc_ME_rel[0:indxTestMax-1],'.r')
plt.plot(nn,b_gc_ME_rel[0:indxTestMax-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$b_{GC}/b_{ME}$',color='m',fontsize=16)
plt.title('Comparison of Distances $b_{GC}$ and $b_{ME}$ between Particles',color='m',fontsize=16)
plt.xlim([-5000,indxTestMax+5000])
# plt.ylim([.9*min(b_gc_ME_rel),1.1*max(b_gc_ME_rel)])
plt.grid(True)
if (saveFilesFlag == 1):
fig2070.savefig('picturesCMA_v7/particleDistanceComprsn_gc_me_fig2070cma.png')
print ('File "picturesCMA_v7/particleDistanceComprsn_gc_me_fig2070cma.png" is written')
#
# Ratio b_gc/b_ME (relative value):
#
if (plotFigureFlag == 0):
fig2080=plt.figure (2080)
# plt.semilogy(nn,actn_gc_ME_rel[0:indxTestMax-1],'.r')
plt.plot(nn,actn_gc_ME_rel[0:indxTestMax-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$10^7\cdot (J_{GC}/J_{ME}$ $-$ $1)$',color='m',fontsize=16)
plt.title('Comparison of Actions $J_{GC}$ and $J_{ME}$',color='m',fontsize=16)
plt.xlim([-5000,indxTestMax+5000])
plt.ylim([.99*min(actn_gc_ME_rel),1.01*max(actn_gc_ME_rel)])
plt.grid(True)
if (saveFilesFlag == 1):
fig2080.savefig('picturesCMA_v7/actionComprsn_gc_me_fig2080cma.png')
print ('File "picturesCMA_v7/actionComprsn_gc_me_fig2080cma.png" is written')
#
# Total length of interaction (1/2 of value):
#
nn=np.arange(0,nVion*nImpctPrmtr,1)
halfLintrTest = np.zeros(nVion*nImpctPrmtr)
for i in range(nVion):
for n in range(nImpctPrmtr):
halfLintrTest[nVion*i+n] = halfLintr[i,n]
if (plotFigureFlag == 0):
fig2090=plt.figure (2090)
plt.semilogy(nn,halfLintrTest,'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$0.5 \cdot L_{Intrctn}$, $cm$',color='m',fontsize=16)
plt.title('Total Length of Interaction: $L_{Intrctn}=2 \cdot [R_{max}^2-rho_{Init}^2)]^{0.5}$', \
color='m',fontsize=16)
plt.xlim([-100,nVion*nImpctPrmtr+100])
plt.ylim([.9*min(halfLintrTest),1.1*max(halfLintrTest)])
plt.grid(True)
if (saveFilesFlag == 1):
fig2090.savefig('picturesCMA/totalLengthIntrsctn_fig2090cma.png')
print ('File "picturesCMA/totalLengthIntrsctn_fig2090cma.png" is written')
#===================================================
#
# There is fitting for correct values of deltaEnrgIon_m
#
#===================================================
#
# Fitting for figures with deltaEnrgIon_m (my own Least Squares Method - LSM;
# Python has own routine for LSM - see site
# http://scipy-cookbook.readthedocs.io/items/FittingData.html):
#
#
# Fittied function:
#
# |deltaEnrgIon| = 10^fitA * rho^fitB,
# so that
#
# log10(|deltaEnrgIon|) = fitB*log10(rho) + fitA
#
# So, the dimension of expression (10^fitA * rho^fitB) is the same
# as deltaEnrgIon, i.e. eV
#
timeStart = os.times()
fitA_dEion = np.zeros(nVion) # dimensionless
fitB_dEion = np.zeros(nVion) # dimensionless
rhoInitFit_dEion = np.zeros((nImpctPrmtr,nVion))
deltaEnrgIon_m_fit = np.zeros((nImpctPrmtr,nVion))
funcHi2_dEion = np.zeros(nVion)
fitA_dEion,fitB_dEion,funcHi2_dEion,rhoInitFit_dEion, deltaEnrgIon_m_fit = \
fitting(nImpctPrmtr,nVion,rhoInit,deltaEnrgIon_m)
dPosA_dEion = np.zeros(nVion)
dNegA_dEion = np.zeros(nVion)
dPosA_dEion,dNegA_dEion = \
errFitAB(nImpctPrmtr,nVion,rhoInit,deltaEnrgIon_m_fit,fitA_dEion,fitB_dEion,funcHi2_dEion,1,2)
dPosB_dEion = np.zeros(nVion)
dNegB_dEion = np.zeros(nVion)
dPosB_dEion,dNegB_dEion = \
errFitAB(nImpctPrmtr,nVion,rhoInit,deltaEnrgIon_m_fit,fitA_dEion,fitB_dEion,funcHi2_dEion,2,2)
# print ('Fitting for deltaEion:')
# for i in range(nVion):
# print ('i=%2d: fitA_dEion = %e (+%e,-%e), fitB_dEion = %e (+%e,-%e), hi2_1 = %e' % \
# (i,fitA_dEion[i],dPosA_dEion[i],dNegA_dEion[i], \
# fitB_dEion[i],dPosB_dEion[i],dNegB_dEion[i],funcHi2_dEion[i]))
#
# Analytical Integration of the fitted dependence 10**A*rho**B.
#
# For this dependece on rho:
#
# Friction force = 10**A*n_e*integral_rhoMin^rhoMax (rho**B*rho)*dRho =
# = 10**A*n_e/(B+2)*[rhoMax**(B+2)-rhoMax**(B+2)] (dimension=eV/cm):
#
frctnForce_AI = np.zeros(nVion)
for i in range(nVion):
factorA1 = math.pow(10.,fitA_dEion[i])
factorB1 = 2.+fitB_dEion[i]
frctnForce_AI[i] = 2.*pi*n_e*100.*factorA1/factorB1* \
(math.pow(impctPrmtrMax[i],factorB1)- \
math.pow(impctPrmtrMin,factorB1)) # eV/m
timeEnd = os.times()
timeFitting = float(timeEnd[0])-float(timeStart[0]) # CPU time , sec
print ('Time of integration = %6.3f seconds' % timeFitting)
#
# Dependences of transferred energy to ion on ion velocity for
# different initial impact parameters:
#
rhoSlctd = [.004,.02,.06,.1]
nRhoSlctd = len(rhoSlctd)
deltaEnrgIon_dpnd_Vi = np.zeros((nRhoSlctd,nVion))
npStart = np.zeros((nRhoSlctd,), dtype=int)
for k in range(nRhoSlctd):
slctdFlag = 0
for i in range(nVion):
if (slctdFlag == 0):
for n in range(nImpctPrmtr):
if (rhoInit[n,i] >= rhoSlctd[k]):
npStart[k] = i
slctdFlag = 1
break
for k in range(nRhoSlctd):
for i in range(npStart[k],nVion,1):
factorA = math.pow(10.,fitA_dEion[i])
deltaEnrgIon_dpnd_Vi[k,i] = factorA*math.pow(rhoSlctd[k],fitB_dEion[i])
# print ('deltaEnrgIon_dpnd_Vi[%d,%d] = %e' %(k,i,deltaEnrgIon_dpnd_Vi[k,i]))
#===================================================
#
# There is fitting of deltaPz_m (these values > 0 always) !!!
#
#===================================================
#
# Fitting for figures with deltaPz_m (my own Least Squares Method - LSM;
# Python has own routine for LSM - see site
# http://scipy-cookbook.readthedocs.io/items/FittingData.html):
#
#
# Fittied function:
#
# deltaPz_m = 10^fitA_pz * rho^fitB_pz,
# so that
#
# log10(deltaPz_m) = fitB_pz*log10(rho) + fitA_pz
#
# So, the dimension of expression (10^fitA_pz * rho^fitB_pz) is the same
# as deltaPz_m, i.e. eV
#
fitA_pz = np.zeros(nVion) # dimensionless
fitB_pz = np.zeros(nVion) # dimensionless
rhoInitFit_pz = np.zeros((nImpctPrmtr,nVion))
deltaPz_m_fit = np.zeros((nImpctPrmtr,nVion))
fitA_pz,fitB_pz,funcHi2_pz,rhoInitFit_pz, deltaPz_m_fit = \
fitting(nImpctPrmtr,nVion,rhoInit,deltaPz_m)
dPosA_pz = np.zeros(nVion)
dNegA_pz = np.zeros(nVion)
dPosA_pz,dNegA_pz = \
errFitAB(nImpctPrmtr,nVion,rhoInit,deltaPz_m_fit,fitA_pz,fitB_pz,funcHi2_pz,1,2)
dPosB_pz = np.zeros(nVion)
dNegB_pz = np.zeros(nVion)
dPosB_pz,dNegB_pz = \
errFitAB(nImpctPrmtr,nVion,rhoInit,deltaPz_m_fit,fitA_pz,fitB_pz,funcHi2_pz,2,2)
# print ('Fitting fordeltaPz_m:')
# for i in range(nVion):
# print ('i=%2d: fitA_pz = %e (+%e,-%e), fitB_pz = %e (+%e,-%e), hi2_1 = %e' % \
# (i,fitA_pz[i],dPosA_pz[i],dNegA_pz[i], \
# fitB_pz[i],dPosB_pz[i],dNegB_pz[i],funcHi2_pz[i]))
# print ('<fitA_pz> = %e +- %e' % (mean(fitA_pz),mean(dNegA_pz)))
# print ('<fitB_pz> = %e +- %e' % (mean(fitB_pz),mean(dNegB_pz)))
#===================================================
#
# There is fitting of deltaPx_m (these values > 0 always) !!!
#
#===================================================
#
rhoInitFit_px = np.zeros((nImpctPrmtr,nVion))
deltaPx_m_fit = np.zeros((nImpctPrmtr,nVion))
funcHi2__px = np.zeros(nVion)
fitA_px = np.zeros(nVion) # dimensionless
fitB_px = np.zeros(nVion) # dimensionless
fitA_px,fitB_px,funcHi2_px,rhoInitFit_px, deltaPx_m_fit = \
fitting(nImpctPrmtr,nVion,rhoInit,deltaPx_m)
dPosA_px = np.zeros(nVion)
dNegA_px = np.zeros(nVion)
dPosA_px,dNegA_px = \
errFitAB(nImpctPrmtr,nVion,rhoInit,deltaPx_m_fit,fitA_px,fitB_px,funcHi2_px,1,2)
dPosB_px = np.zeros(nVion)
dNegB_px = np.zeros(nVion)
dPosB_px,dNegB_px = \
errFitAB(nImpctPrmtr,nVion,rhoInit,deltaPx_m_fit,fitA_px,fitB_px,funcHi2_px,2,2)
# print ('Fitting for deltaPx_m:')
# for i in range(nVion):
# print ('i=%2d: fitA_px = %e (+%e,-%e), fitB_px = %e (+%e,-%e), hi2_1 = %e' % \
# (i,fitA_px[i],dPosA_px[i],dNegA_px[i], \
# fitB_px[i],dPosB_px[i],dNegB_px[i],funcHi2_px[i]))
xLimit = [1.015*np.log10(VionRel[0]),.95*np.log10(VionRel[nVion-1])]
yLimMin = 0.
yLimMax = 10.*min(fitA_pz)
if (min(fitA_pz) > 0):
yLimMin = 10.*max(fitA_pz)
yLimMax = 0.
for i in range(nVion):
if (fitA_pz[i] - dNegA_pz[i]) < yLimMin:
yLimMin = fitA_pz[i] - dNegA_pz[i]
if (fitA_pz[i] + dPosA_pz[i]) > yLimMax:
yLimMax = fitA_pz[i] + dPosA_pz[i]
# print ('Exponent A (pz): yLimMin = %e, yLimMax = %e' % (yLimMin,yLimMax))
yLimit = [yLimMin-.25,yLimMax+.25]
if (plotFigureFlag == 0):
fig3000=plt.figure (3000)
plt.errorbar(np.log10(VionRel),fitA_pz,yerr=[dNegA_pz,dPosA_pz],fmt='-ro', \
ecolor='b',capsize=5,capthick=1)
plt.xlabel('Relative Ion Velocity, $log_{10}(V_{ion}/V_0)$',color='m',fontsize=14)
plt.ylabel('Exponent $A$', color='m',fontsize=14)
titleHeader = 'Dependence of Transferred Momenta to Single Ion: '
titleHeader += '$\Delta P_z$ = $10^A\cdot rho^B$'
plt.title(titleHeader,color='m',fontsize=12)
plt.text(-3.75,-26.0,('$V_{e0}=%5.3f\cdot10^{%2d}$cm/s' % (mantV0,powV0)), \
color='m',fontsize=16)
plt.text(-4.0,-28.,('<A>=%7.3f $\pm$ %5.3f' % (mean(fitA_pz),mean(dNegA_pz))), \
color='r',fontsize=16)
# plt.text(-3.25,-29.65,('$-$%5.3f' % (mean(dNegA_pz))),color='r',fontsize=12)
# plt.text(-3.25,-29.15,('$+$%5.3f' % (mean(dPosA_pz))),color='r',fontsize=12)
plt.xlim(xLimit)
plt.ylim(yLimit)
plt.grid(True)
plt.plot([np.log10(relVeTrnsv),np.log10(relVeTrnsv)],yLimit,'--m',linewidth=1)
plt.text(-2.55,-28.25,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([np.log10(relVeLong),np.log10(relVeLong)],yLimit,'--m',linewidth=1)
plt.text(-4.24,-28.25,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
if (saveFilesFlag == 1):
fig3000.savefig('picturesCMA_v7/fitA_dPz_fig3000cma.png')
print ('File "picturesCMA_v7/fitA_dPz_fig3000cma.png" is written')
yLimMin = 0.
yLimMax = 10.*min(fitB_pz)
if (min(fitB_pz) > 0):
yLimMin = 10.*max(fitB_pz)
yLimMax = 0.
for i in range(nVion):
if (fitB_pz[i] - dNegB_pz[i]) < yLimMin:
yLimMin = fitB_pz[i] - dNegB_pz[i]
if (fitB_pz[i] + dPosB_pz[i]) > yLimMax:
yLimMax = fitB_pz[i] + dPosB_pz[i]
# print ('Exponent B (pz): yLimMin = %e, yLimMax = %e' % (yLimMin,yLimMax))
yLimit = [yLimMin-.1,yLimMax+.1]
if (plotFigureFlag == 0):
fig3010=plt.figure (3010)
plt.errorbar(np.log10(VionRel),fitB_pz,yerr=[dNegB_pz,dPosB_pz],fmt='-ro', \
ecolor='b',capsize=5,capthick=1)
plt.xlabel('Relative Ion Velocity, $log_{10}(V_{ion}/V_0)$',color='m',fontsize=14)
plt.ylabel('Exponent $B$', color='m',fontsize=14)
titleHeader = 'Dependence of Transferred Momenta to Single Ion: '
titleHeader += '$\Delta P_z$ = $10^A\cdot rho^B$'
plt.title(titleHeader,color='m',fontsize=12)
plt.text(-3.75,-.87,('$V_{e0}=%5.3f\cdot10^{%2d}$cm/s' % (mantV0,powV0)), \
color='m',fontsize=16)
plt.text(-3.9,-1.55,('<B>=%6.3f $\pm$ %5.3f' % (mean(fitB_pz),mean(dNegB_pz))), \
color='r',fontsize=16)
# plt.text(-2.85,-2.25,('$-$%5.3f' % (mean(dNegB_pz))),color='r',fontsize=12)
# plt.text(-2.85,-1.75,('$+$%5.3f' % (mean(dPosB_pz))),color='r',fontsize=12)
plt.xlim(xLimit)
plt.ylim(yLimit)
plt.grid(True)
plt.plot([np.log10(relVeTrnsv),np.log10(relVeTrnsv)],yLimit,'--m',linewidth=1)
plt.text(-2.55,-1.74,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([np.log10(relVeLong),np.log10(relVeLong)],yLimit,'--m',linewidth=1)
plt.text(-4.24,-1.74,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
if (saveFilesFlag == 1):
fig3010.savefig('picturesCMA_v7/fitB_dPz_fig3010cma.png')
print ('File "picturesCMA_v7/fitB_dPz_fig3010cma.png" is written')
yLimMin = 0.
yLimMax = 10.*min(fitA_px)
if (min(fitA_px) > 0):
yLimMin = 10.*max(fitA_px)
yLimMax = 0.
for i in range(nVion):
if (fitA_px[i] - dNegA_px[i]) < yLimMin:
yLimMin = fitA_px[i] - dNegA_px[i]
if (fitA_px[i] + dPosA_px[i]) > yLimMax:
yLimMax = fitA_px[i] + dPosA_px[i]
# print ('Exponent A (px): yLimMin = %e, yLimMax = %e' % (yLimMin,yLimMax))
yLimit = [yLimMin-.15,yLimMax+.15]
if (plotFigureFlag == 0):
fig3020=plt.figure (3020)
plt.errorbar(np.log10(VionRel),fitA_px,yerr=[dNegA_px,dPosA_px],fmt='-ro', \
ecolor='b',capsize=5,capthick=1)
plt.xlabel('Relative Ion Velocity, $log_{10}(V_{ion}/V_0)$',color='m',fontsize=14)
plt.ylabel('Exponent $A$', color='m',fontsize=14)
titleHeader = 'Dependence of Transferred Momenta to Single Ion: '
titleHeader += '$\Delta P_x$ = $10^A\cdot rho^B$'
plt.title(titleHeader,color='m',fontsize=12)
plt.text(-3.75,-24.2,('$V_{e0}=%5.3f\cdot10^{%2d}$cm/s' % (mantV0,powV0)), \
color='m',fontsize=16)
plt.text(-3.9,-24.8,('<A>=%6.3f $\pm$ %5.3f' % (mean(fitA_px),mean(dNegA_px))), \
color='r',fontsize=16)
plt.xlim(xLimit)
plt.ylim(yLimit)
plt.grid(True)
plt.plot([np.log10(relVeTrnsv),np.log10(relVeTrnsv)],yLimit,'--m',linewidth=1)
plt.text(-2.55,-25.05,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([np.log10(relVeLong),np.log10(relVeLong)],yLimit,'--m',linewidth=1)
plt.text(-4.24,-25.05,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
if (saveFilesFlag == 1):
fig3020.savefig('picturesCMA_v7/fitA_dPx_fig3020cma.png')
print ('File "picturesCMA_v7/fitA_dPx_fig3020cma.png" is written')
yLimMin = 0.
yLimMax = 10.*min(fitB_px)
if (min(fitB_px) > 0):
yLimMin = 10.*max(fitB_px)
yLimMax = 0.
for i in range(nVion):
if (fitB_px[i] - dNegB_px[i]) < yLimMin:
yLimMin = fitB_px[i] - dNegB_px[i]
if (fitB_px[i] + dPosB_px[i]) > yLimMax:
yLimMax = fitB_px[i] + dPosB_px[i]
# print ('Exponent B (px): yLimMin = %e, yLimMax = %e' % (yLimMin,yLimMax))
yLimit = [yLimMin-.05,yLimMax+.05]
if (plotFigureFlag == 0):
fig3030=plt.figure (3030)
plt.errorbar(np.log10(VionRel),fitB_px,yerr=[dNegB_px,dPosB_px],fmt='-ro', \
ecolor='b',capsize=5,capthick=1)
plt.xlabel('Relative Ion Velocity, $log_{10}(V_{ion}/V_0)$',color='m',fontsize=14)
plt.ylabel('Exponent $B$', color='m',fontsize=14)
titleHeader = 'Dependence of Transferred Momenta to Single Ion: '
titleHeader += '$\Delta P_x$ = $10^A\cdot rho^B$'
plt.title(titleHeader,color='m',fontsize=12)
plt.text(-3.75,-.95,('$V_{e0}=%5.3f\cdot10^{%2d}$cm/s' % (mantV0,powV0)), \
color='m',fontsize=16)
plt.text(-3.9,-1.15,('<B>=%6.3f $\pm$ %5.3f' % (mean(fitB_px),mean(dNegB_px))), \
color='r',fontsize=16)
plt.xlim(xLimit)
plt.ylim(yLimit)
plt.grid(True)
plt.plot([np.log10(relVeTrnsv),np.log10(relVeTrnsv)],yLimit,'--m',linewidth=1)
plt.text(-2.55,-1.22,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([np.log10(relVeLong),np.log10(relVeLong)],yLimit,'--m',linewidth=1)
plt.text(-4.24,-1.22,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
if (saveFilesFlag == 1):
fig3030.savefig('picturesCMA_v7/fitB_dPx_fig3030cma.png')
print ('File "picturesCMA/_v7/fitB_dPx_fig3030cma.png" is written')
# plt.show()
# sys.exit()
#
#=======================================================
#
# Main plotting:
#
if (plotFigureFlag == 0):
fig110=plt.figure (110)
plt.plot(arrayA,arrayB,'.r')
plt.xlabel('$A=log_{10}(q_e^2/b/E_{kin})$',color='m',fontsize=16)
plt.ylabel('$B=log_{10}(R_{Larm}/b)$',color='m',fontsize=16)
plt.title('Map of Parameters A,B', color='m',fontsize=16)
# plt.xlim([minA,maxA])
# plt.ylim([minB,maxB])
plt.grid(True)
if (saveFilesFlag == 1):
fig110.savefig('picturesCMA/mapA-B_fig110cma.png')
print ('File "picturesCMA/mapA-B_fig110cma.png" is written')
if (plotFigureFlag == 0):
fig20=plt.figure (20)
plt.plot(nnTotalPoints,bCrrnt_c[0:2*totalPoints-1],'.r')
# plt.semilogy(nn,bCrrnt_c[0:2*totalPoints-1],'.r')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$b_{Lab.Sys}$, $cm$',color='m',fontsize=16)
plt.title('Distance $b_{Lab.Sys}$ between Particles in Lab.System', color='m',fontsize=16)
plt.xlim([-5000,2*totalPoints+5000])
# plt.xlim([0,2000])
plt.grid(True)
if (saveFilesFlag == 1):
fig20.savefig('picturesCMA/particleDistance_ls_fig20cma.png')
print ('File "picturesCMA/particleDistance_ls_fig20cma.png" is written')
if (plotFigureFlag == 0):
fig30=plt.figure (30)
plt.plot(nnTotalPoints,arrayA[0:2*totalPoints-1],'.r', \
nnTotalPoints,arrayB[0:2*totalPoints-1],'.b')
plt.xlabel('Points of Tracks',color='m',fontsize=16)
plt.ylabel('$A$, $B$',color='m',fontsize=16)
plt.title('$A=log_{10}(q_e^2/b/E_{kin})$, $B=log_{10}(R_{Larm}/b)$',color='m',fontsize=16)
plt.xlim([-5000,2*totalPoints+5000])
# plt.ylim([minB,maxB])
plt.grid(True)
plt.legend(['A','B'],loc='lower left',fontsize=14)
if (saveFilesFlag == 1):
fig30.savefig('picturesCMA/parametersA-B_fig30cma.png')
print ('File "picturesCMA/parametersA-B_fig30cma.png" is written')
xVionRel = np.zeros((nImpctPrmtr,nVion))
for i in range(nVion):
for n in range(nImpctPrmtr):
xVionRel[n,i] = VionRel[i]
if (plotFigureFlag == 0):
fig40=plt.figure (40)
for i in range(nVion):
plt.semilogx(xVionRel[0:nImpctPrmtr,i],rhoInit[0:nImpctPrmtr,i],'.r')
plt.xlabel('Relative Ion Velocity, $V_i/V_{e0}$',color='m',fontsize=16)
plt.ylabel('$rho_{Init}$, cm',color='m',fontsize=16)
plt.title('Subdivisions for $rho_{Init}$ for Integration: Simpson Method', \
color='m',fontsize=16)
plt.grid(True)
yLimit=[0.,.405]
plt.ylim(yLimit)
plt.plot([relVeTrnsv,relVeTrnsv],yLimit,'--m',linewidth=1)
plt.text(1.6e-3,-.026,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([relVeLong,relVeLong],yLimit,'--m',linewidth=1)
plt.text(3.9e-5,.05,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
if (saveFilesFlag == 1):
fig40.savefig('picturesCMA/initialImpactParameter_SM_fig40cma.png')
print ('File "picturesCMA/initialImpactParameter_SM_fig40cma.png" is written')
if (plotFigureFlag == 0):
fig45=plt.figure (45)
for i in range(nVion):
plt.loglog(xVionRel[0:nImpctPrmtr,i],rhoInit[0:nImpctPrmtr,i],'.r')
plt.xlabel('Relative Ion Velocity, $V_i/V_{e0}$',color='m',fontsize=16)
plt.ylabel('$rho_{Init}$, cm',color='m',fontsize=16)
plt.title('Subdivisions for $rho_{Init}$ for Integration: Simpson Method', \
color='m',fontsize=16)
plt.grid(True)
yLimit=[1.3e-3,.45]
plt.ylim(yLimit)
plt.plot([relVeTrnsv,relVeTrnsv],yLimit,'--m',linewidth=1)
plt.text(1.6e-3,.15,'$ \Delta V_{e\perp}/ V_{e0}$',color='m',fontsize=14)
plt.plot([relVeLong,relVeLong],yLimit,'--m',linewidth=1)
plt.text(3.9e-5,.15,'$ \Delta V_{e||}/ V_{e0}$',color='m',fontsize=14)
if (saveFilesFlag == 1):
fig45.savefig('picturesCMA/initialImpactParameter_SM_fig45cma.png')
print ('File "picturesCMA/initialImpactParameter_SM_fig45cma.png" is written')
'''
#
# Figure compares calculated values of of deltaEnrgIon (their dependences
# on impact parameter for different ion velocities) for two approaches
# (figure numbrFigures[0]+1 is the same and taking into account positive and
# negative values of the deltaEnrgIon_c for guiding center approach):
#
VionCrrnt = V0*VionRel[0]
powVionCrrnt = math.floor(np.log10(VionCrrnt))
mantVionCrrnt = VionCrrnt/(10**powVionCrrnt)
plt.figure (50)
plt.loglog(rhoInit[0:nImpctPrmtr-1,0],deltaEnrgIon_c[0:nImpctPrmtr-1,0],'-xr', \
rhoInit[0:nImpctPrmtr-1,0],deltaEnrgIon_m[0:nImpctPrmtr-1,0],'--or', \
linewidth=1)
plt.xlabel('Track Initial Impact Parameter $rho_{Init}$', color='m',fontsize=16)
plt.ylabel('$\Delta E_{ion}$, $erg$', color='m',fontsize=16)
titleHeader = 'Transferred Energy $\Delta E_{ion}$ to Ion for '
titleHeader += ' $V_{ion}=%5.3f\cdot10^{%2d}$ $cm/s$'
plt.title(titleHeader % (mantVionCrrnt,powVionCrrnt),color='m',fontsize=16)
plt.xlim([.95*rhoInit[0,0],1.05*rhoInit[nImpctPrmtr-1,0]])
plt.grid(True)
xRhoInitPx_c = np.zeros(nImpctPrmtr*nVion)
xRhoInitPx_m = np.zeros(nImpctPrmtr*nVion)
yDeltaPx_c = np.zeros(nImpctPrmtr*nVion)
yDeltaPx_m = np.zeros(nImpctPrmtr*nVion)
indx_c = 0
indx_m = 0
for n in range(nImpctPrmtr):
if deltaPx_c[n,0] > 0.:
xRhoInitPx_c[indx_c] = rhoInit[n,0]
yDeltaPx_c[indx_c] = deltaPx_c[n,0]
# print ('n_c=%2d: xRhoInitPx_c = %e, yDeltaPx_c = %e' % \
# (indx_c,xRhoInitPx_c[indx_c],yDeltaPx_c[indx_c]))
indx_c += 1
if deltaPx_m[n,0] > 0.:
xRhoInitPx_m[indx_c] = rhoInit[n,0]
yDeltaPx_m[indx_c] = deltaPx_m[n,0]
# print ('n_m=%2d: xRhoInitPx_m = %e, yDeltaPx_m = %e' % \
# (indx_m,xRhoInitPx_m[indx_m],yDeltaPx_m[indx_m]))
indx_m += 1
maxIndx_c = indx_c-1
maxIndx_m = indx_m-1
# print ('maxIndx_c = %d, maxIndx_m = %d' % (maxIndx_c,maxIndx_m))
#
# Figure compares calculated values of of deltaPx (their dependences
# on impact parameter for different ion velocities) for two approaches
# (figure numbrFigures[0]+2 is the same and taking into account positive and
# negative values of the deltaPx_c for guiding center approach):
#
plt.figure (51)
plt.loglog(xRhoInitPx_c[0:maxIndx_c],yDeltaPx_c[0:maxIndx_c],'-xr', \
xRhoInitPx_m[0:maxIndx_m],yDeltaPx_m[0:maxIndx_m],'--or', \
linewidth=1)
plt.xlabel('Track Initial Impact Parameter $rho_{Init}$, $cm$', \
color='m',fontsize=16)
plt.ylabel('$\Delta P_{ix}$, $g\cdot cm/s$', color='m',fontsize=16)
titleHeader = 'Transferred Momenta $\Delta P_{ix}$ to Ion for '
titleHeader += ' $V_{ion}=%5.3f\cdot10^{%2d}$ $cm/s$'
plt.title(titleHeader % (mantVionCrrnt,powVionCrrnt),color='m',fontsize=16)
plt.xlim([.95*min(xRhoInitPx_c[0],xRhoInitPx_m[0]), \
1.05*max(xRhoInitPx_c[maxIndx_c],xRhoInitPx_m[maxIndx_m])])
plt.grid(True)
xRhoInitPz_c = np.zeros(nImpctPrmtr*nVion)
xRhoInitPz_m = np.zeros(nImpctPrmtr*nVion)
yDeltaPz_c = np.zeros(nImpctPrmtr*nVion)
yDeltaPz_m = np.zeros(nImpctPrmtr*nVion)
indx_c = 0
indx_m = 0
for n in range(nImpctPrmtr):
if deltaPz_c[n,0] > 0.:
xRhoInitPz_c[indx_c] = rhoInit[n,0]
yDeltaPz_c[indx_c] = deltaPz_c[n,0]
# print ('n_c=%2d: xRhoInitPz_c = %e, yDeltaPz_c = %e' % \
# (indx_c,xRhoInitPz_c[indx_c],yDeltaPz_c[indx_c]))
indx_c += 1
if deltaPz_m[n,0] > 0.:
xRhoInitPz_m[indx_c] = rhoInit[n,0]
yDeltaPz_m[indx_c] = deltaPz_m[n,0]
# print ('n_m=%2d: xRhoInitPz_m = %e, yDeltaPz_m = %e' % \
# (indx_m,xRhoInitPz_m[indx_m],yDeltaPz_m[indx_m]))
indx_m += 1
maxIndx_c = indx_c-1
maxIndx_m = indx_m-1
# print ('maxIndx_c = %d, maxIndx_m = %d' % (maxIndx_c,maxIndx_m))
#
# Figure compares calculated values of of deltaPz (their dependences
# on impact parameter for different ion velocities) for two approaches
# (figure numbrFigures[0]+5):
#
plt.figure (53)
plt.loglog(xRhoInitPz_c[0:maxIndx_c],yDeltaPz_c[0:maxIndx_c],'-xr', \
xRhoInitPz_m[0:maxIndx_m],yDeltaPz_m[0:maxIndx_m],'--or', \
linewidth=1)
plt.xlabel('Track Initial Impact Parameter $rho_{Init}$, $cm$', \
color='m',fontsize=16)
plt.ylabel('$\Delta P_{iz}$, $g\cdot cm/s$', color='m',fontsize=16)
titleHeader = 'Transferred Momenta $\Delta P_{iz}$ to Ion for '
titleHeader += ' $V_{ion}=%5.3f\cdot10^{%2d}$ $cm/s$'
plt.title(titleHeader % (mantVionCrrnt,powVionCrrnt),color='m',fontsize=16)
plt.xlim([.95*min(xRhoInitPz_c[0],xRhoInitPz_m[0]), \
1.05*max(xRhoInitPz_c[maxIndx_c],xRhoInitPz_m[maxIndx_m])])
plt.grid(True)
'''
#
# Figures 60,70,80, and 90 compare calculated values of of deltaEnrgIon
# (their dependences on impact parameter for first values of ion velocities)
# for two approaches (figure numbrFigures[*]+1 is the same and taking into
# account positive and negative values of the deltaEnrgIon_c for guiding center approach):
#
'''
VionCrrnt = V0*VionRel[1]
powVionCrrnt = math.floor(np.log10(VionCrrnt))
mantVionCrrnt = VionCrrnt/(10**powVionCrrnt)
plt.figure (60)
plt.loglog(rhoInit[0:nImpctPrmtr-1,1],deltaEnrgIon_c[0:nImpctPrmtr-1,1],'-xb', \
rhoInit[0:nImpctPrmtr-1,1],deltaEnrgIon_m[0:nImpctPrmtr-1,1],'--ob', \
linewidth=1)
plt.xlabel('Track Initial Impact Parameter $rho_{Init}$', \
color='m',fontsize=16)
plt.ylabel('$\Delta E_{ion}$, $erg$', color='m',fontsize=16)
titleHeader = 'Transferred Energy $\Delta E_{ion}$ to Ion for '
titleHeader += ' $V_{ion}=%5.3f\cdot10^{%2d}$ $cm/s$'
plt.title(titleHeader % (mantVionCrrnt,powVionCrrnt),color='m',fontsize=16)
plt.xlim([.95*rhoInit[0,1],1.05*rhoInit[nImpctPrmtr-1,1]])
plt.grid(True)
VionCrrnt = V0*VionRel[2]
powVionCrrnt = math.floor(np.log10(VionCrrnt))
mantVionCrrnt = VionCrrnt/(10**powVionCrrnt)
plt.figure (70)
plt.loglog(rhoInit[0:nImpctPrmtr-1,2],deltaEnrgIon_c[0:nImpctPrmtr-1,2],'-xg', \
rhoInit[0:nImpctPrmtr-1,2],deltaEnrgIon_m[0:nImpctPrmtr-1,2],'--og', \
linewidth=1)
plt.xlabel('Track Initial Impact Parameter $rho_{Init}$', \
color='m',fontsize=16)
plt.ylabel('$\Delta E_{ion}$, $erg$', color='m',fontsize=16)
titleHeader = 'Transferred Energy $\Delta E_{ion}$ to Ion for '
titleHeader += ' $V_{ion}=%5.3f\cdot10^{%2d}$ $cm/s$'
plt.title(titleHeader % (mantVionCrrnt,powVionCrrnt),color='m',fontsize=16)
plt.xlim([.95*rhoInit[0,2],1.05*rhoInit[nImpctPrmtr-1,2]])
plt.grid(True)
VionCrrnt = V0*VionRel[3]
powVionCrrnt = math.floor(np.log10(VionCrrnt))
mantVionCrrnt = VionCrrnt/(10**powVionCrrnt)
plt.figure (80)
plt.loglog(rhoInit[0:nImpctPrmtr-1,3],deltaEnrgIon_c[0:nImpctPrmtr-1,3],'-xk', \
rhoInit[0:nImpctPrmtr-1,3],deltaEnrgIon_m[0:nImpctPrmtr-1,3],'--ok', \
linewidth=1)
plt.xlabel('Track Initial Impact Parameter $rho_{Init}$', \
color='m',fontsize=16)
plt.ylabel('$\Delta E_{ion}$, $erg$', color='m',fontsize=16)
titleHeader = 'Transferred Energy $\Delta E_{ion}$ to Ion for '
titleHeader += ' $V_{ion}=%5.3f\cdot10^{%2d}$ $cm/s$'
plt.title(titleHeader % (mantVionCrrnt,powVionCrrnt),color='m',fontsize=16)
plt.xlim([.95*rhoInit[0,3],1.05*rhoInit[nImpctPrmtr-2,3]])
plt.grid(True)
VionCrrnt = V0*VionRel[4]
powVionCrrnt = math.floor(np.log10(VionCrrnt))
mantVionCrrnt = VionCrrnt/(10**powVionCrrnt)
plt.figure (90)
plt.loglog(rhoInit[0:nImpctPrmtr-1,4],deltaEnrgIon_c[0:nImpctPrmtr-1,4],'-xm', \
rhoInit[0:nImpctPrmtr-1,4],deltaEnrgIon_m[0:nImpctPrmtr-1,4],'--om', \
linewidth=1)
plt.xlabel('Track Initial Impact Parameter $rho_{Init}$', \
color='m',fontsize=16)
plt.ylabel('$\Delta E_{ion}$, $erg$', color='m',fontsize=16)
titleHeader = 'Transferred Energy $\Delta E_{ion}$ to Ion for '
titleHeader += ' $V_{ion}=%5.3f\cdot10^{%2d}$ $cm/s$'
plt.title(titleHeader % (mantVionCrrnt,powVionCrrnt),color='m',fontsize=16)
plt.xlim([.95*rhoInit[0,4],1.05*rhoInit[nImpctPrmtr-1,4]])
plt.grid(True)
'''
#
# Dependences of transferred energy to ion and different momenta on initial
# impact parameter for different ion velocity (calculated and fitted values):
#
indxFigures = [0,9,12,18,19,23,27,29,31,34,39,49]
numbrFigures = [500,600,630,660,700,730,760,800,830,860,900,1000]
xPos = [.00218,.0022,.0024,.0027,.0026,.00265,.00265,.00265,.00265,.0028,.0029,.0035]
yPos = [6.4e-9,6.7e-9,6.4e-9,5.9e-9,6.2e-9,5.6e-9,5.8e-9,6.3e-9,5.8e-9,5.9e-9,5.8e-9,4.7e-9]
if (plotFigureFlag == 0):
for i in range(12):
VionCrrnt = V0*VionRel[indxFigures[i]]
powVionCrrnt = math.floor(np.log10(VionCrrnt))
mantVionCrrnt = VionCrrnt/(10**powVionCrrnt)
#
# Pz:
#
posPz_c = np.zeros((12,nImpctPrmtr))
rhoPosPz_c = np.zeros((12,nImpctPrmtr))
negPz_c = np.zeros((12,nImpctPrmtr))
rhoNegPz_c = np.zeros((12,nImpctPrmtr))
posPz_m = np.zeros((12,nImpctPrmtr))
rhoPosPz_m = np.zeros((12,nImpctPrmtr))
negPz_m = np.zeros((12,nImpctPrmtr))
rhoNegPz_m = np.zeros((12,nImpctPrmtr))
nPosPz_c = array('i',[0]*12)
nNegPz_c = array('i',[0]*12)
nPosPz_m = array('i',[0]*12)
nNegPz_m = array('i',[0]*12)
for i in range(12):
nPosPz_c[i] = -1
nNegPz_c[i] = -1
nPosPz_m[i] = -1
nNegPz_m[i] = -1
for k in range(nImpctPrmtr):
if (deltaPz_c[k,indxFigures[i]] > 0):
nPosPz_c[i] += 1
rhoPosPz_c[i,nPosPz_c[i]] = rhoInit[k,indxFigures[i]]
posPz_c[i,nPosPz_c[i]] = deltaPz_c[k,indxFigures[i]]
if (deltaPz_c[k,indxFigures[i]] <= 0):
nNegPz_c[i] += 1
rhoNegPz_c[i,nNegPz_c[i]] = rhoInit[k,indxFigures[i]]
negPz_c[i,nNegPz_c[i]] = abs(deltaPz_c[k,indxFigures[i]])
if (deltaPz_m[k,indxFigures[i]] > 0):
nPosPz_m[i] += 1
rhoPosPz_m[i,nPosPz_m[i]] = rhoInit[k,indxFigures[i]]
posPz_m[i,nPosPz_m[i]] = deltaPz_m[k,indxFigures[i]]
if (deltaPz_m[k,indxFigures[i]] <= 0):
nNegPz_m[i] += 1
rhoNegPz_m[i,nNegPz_m[i]] = rhoInit[k,indxFigures[i]]
negPz_m[i,nNegPz_m[i]] = abs(deltaPz_m[k,indxFigures[i]])
# print ('i=%d: nPosPz_c=%d, nNegPz_c=%d, nPosPz_m=%d, nNegPz_m=%d' % \
# (i,nPosPz_c[i],nNegPz_c[i],nPosPz_m[i],nNegPz_m[i]))
#
# Figures to compare calculated values of of deltaPz (their dependences
# on impact parameter for different ion velocities) for two approaches
#
if (plotFigureFlag == 0):
for i in range(12):
VionCrrnt = V0*VionRel[indxFigures[i]]
powVionCrrnt = math.floor( | np.log10(VionCrrnt) | numpy.log10 |
import numpy as np
import pdb
import pywt
## This file is imported from the modwt wavelet transform provided at:
## https://github.com/pistonly/modwtpy
## It appears that pywavelet does not have the maximal ovalap discrete wavelet transform.
def upArrow_op(li, j):
if j == 0:
return [1]
N = len(li)
li_n = np.zeros(2 ** (j - 1) * (N - 1) + 1)
for i in range(N):
li_n[2 ** (j - 1) * i] = li[i]
return li_n
def period_list(li, N):
n = len(li)
# append [0 0 ...]
n_app = N - np.mod(n, N)
li = list(li)
li = li + [0] * n_app
if len(li) < 2 * N:
return np.array(li)
else:
li = np.array(li)
li = np.reshape(li, [-1, N])
li = np.sum(li, axis=0)
return li
def circular_convolve_mra(h_j_o, w_j):
''' calculate the mra D_j'''
N = len(w_j)
l = np.arange(N)
D_j = np.zeros(N)
for t in range(N):
index = np.mod(t + l, N)
w_j_p = np.array([w_j[ind] for ind in index])
D_j[t] = (np.array(h_j_o) * w_j_p).sum()
return D_j
def circular_convolve_d(h_t, v_j_1, j):
'''
jth level decomposition
h_t: \tilde{h} = h / sqrt(2)
v_j_1: v_{j-1}, the (j-1)th scale coefficients
return: w_j (or v_j)
'''
N = len(v_j_1)
L = len(h_t)
w_j = np.zeros(N)
l = np.arange(L)
for t in range(N):
index = np.mod(t - 2 ** (j - 1) * l, N)
v_p = np.array([v_j_1[ind] for ind in index])
w_j[t] = (np.array(h_t) * v_p).sum()
return w_j
def circular_convolve_s(h_t, g_t, w_j, v_j, j):
'''
(j-1)th level synthesis from w_j, w_j
see function circular_convolve_d
'''
N = len(v_j)
L = len(h_t)
v_j_1 = np.zeros(N)
l = np.arange(L)
for t in range(N):
index = np.mod(t + 2 ** (j - 1) * l, N)
w_p = np.array([w_j[ind] for ind in index])
v_p = np.array([v_j[ind] for ind in index])
v_j_1[t] = (np.array(h_t) * w_p).sum()
v_j_1[t] = v_j_1[t] + (np.array(g_t) * v_p).sum()
return v_j_1
def modwt(x, filters, level):
'''
filters: 'db1', 'db2', 'haar', ...
return: see matlab
'''
# filter
wavelet = pywt.Wavelet(filters)
h = wavelet.dec_hi
g = wavelet.dec_lo
h_t = np.array(h) / np.sqrt(2)
g_t = np.array(g) / np.sqrt(2)
wavecoeff = []
v_j_1 = x
for j in range(level):
w = circular_convolve_d(h_t, v_j_1, j + 1)
v_j_1 = circular_convolve_d(g_t, v_j_1, j + 1)
wavecoeff.append(w)
wavecoeff.append(v_j_1)
return | np.vstack(wavecoeff) | numpy.vstack |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 17 13:53:36 2020
@author: chrisbartel
"""
from compmatscipy.CompAnalyzer import CompAnalyzer
import numpy as np
from scipy.optimize import nnls
from compmatscipy.TrianglePlots import get_label
class ReactionAnalysis(object):
def __init__(self, reactants, products,
el_open, num_closed):
self.reactants = list(set(reactants))
self.products = list(set([p for p in products if p not in reactants]))
self.el_open = el_open
self.num_closed = num_closed
@property
def all_els(self):
r, p = self.reactants, self.products
els = [CompAnalyzer(c).els for c in r+p]
els = [j for i in els for j in i]
return sorted(list(set(els)))
@property
def balance_els(self):
els = self.all_els
el_open = self.el_open
if not el_open:
return els
return [el for el in els if el != el_open]
@property
def A(self):
r, p = self.reactants, self.products
balance_els = self.balance_els
A = np.zeros(shape=(len(r)+len(p), len(balance_els)+len(p)))
A = A.T
for i in range(len(balance_els)):
count = 0
for j in range(len(r)+len(p)):
count += 1
if count <= len(r):
sign = 1
cmpd = r[j]
else:
sign = -1
cmpd = p[j-len(r)]
A[i, j] = sign*CompAnalyzer(cmpd).amt_of_el(balance_els[i])
line = [0 for i in range(len(r))]
for j in range(len(p)):
line.append(np.sum([CompAnalyzer(p[j]).amt_of_el(el) for el in balance_els]))
A[-1] = line
return np.array(A)
@property
def b(self):
r, p = self.reactants, self.products
balance_els = self.balance_els
b = np.zeros(shape=(len(balance_els)+len(p), 1))
b[-1] = self.num_closed
b = [b[i][0] for i in range(len(b))]
return np.array(b)
@property
def solution(self):
A, b = self.A, self.b
return nnls(A, b)
@property
def species(self):
coefs = {}
r, p = self.reactants, self.products
components = r + p
solution = self.solution
for i in range(len(components)):
coefs[components[i]] = solution[0][i]
species = {reac : {'side' : 'left', 'amt' : coefs[reac]} for reac in r}
for prod in p:
species[prod] = {'side' : 'right',
'amt' : coefs[prod]}
return species
def fancy_reaction_string(self, order):
species = self.species
rxn = r''
reactants = [s for s in species if species[s]['side'] == 'left']
products = [s for s in species if species[s]['side'] == 'right']
count = 0
for r in reactants:
amt = species[r]['amt']
if amt == 0:
continue
if amt != 1:
rxn += str(amt)
rxn += get_label(r, order)
count += 1
if count < len(reactants):
rxn += '+'
rxn += r'$\rightarrow$'
count = 0
for p in products:
amt = species[p]['amt']
if amt == 0:
continue
if amt != 1:
rxn += str(amt)
rxn += get_label(p, order)
count += 1
if count < len(products):
rxn += '+'
rxn += r''
return rxn
def reaction_string(self, order):
species = self.species
rxn = r''
reactants = [s for s in species if species[s]['side'] == 'left']
products = [s for s in species if species[s]['side'] == 'right']
count = 0
for r in reactants:
count += 1
amt = species[r]['amt']
amt = np.round(amt, 3)
if amt < 1e-4:
continue
if amt != 1:
rxn += str(amt)
rxn += '_'
rxn += r
if count < len(reactants):
rxn += ' + '
count = 0
rxn += ' ---> '
for p in products:
count += 1
amt = species[p]['amt']
amt = | np.round(amt, 3) | numpy.round |
from sklearn.preprocessing import LabelEncoder
import numpy as np
'''
By using LabelEncoder to create the labelencoder of slot-tags
'''
class TagsVectorizer:
def __init__(self):
pass
def tokenize(self, tags_str_arr):
return [s.split() for s in tags_str_arr]
def fit(self, train_tags_str_arr, val_tags_str_arr):
## in order to avoid, in valid_dataset, there is tags which not exit in train_dataset. like: ATIS datset
self.label_encoder = LabelEncoder()
data = ["[padding]", "[CLS]", "[SEP]"] + [item for sublist in self.tokenize(train_tags_str_arr) for item in sublist]
data = data + [item for sublist in self.tokenize(val_tags_str_arr) for item in sublist]
## # data: ["[padding]", "[CLS]", "[SEP]", all of the real tags]; add the "[padding]", "[CLS]", "[SEP]" for the real tag list
self.label_encoder.fit(data)
def transform(self, tags_str_arr, valid_positions):
## if we set the maximum length is 50, then the seq_length is 50; otherwise, it will be equal to the maximal length of dataset
seq_length = valid_positions.shape[1] # .shape[0]: number of rows, .shape[1]: number of columns
data = self.tokenize(tags_str_arr)
## we added the 'CLS' and 'SEP' token as the first and last token for every sentence respectively
data = [self.label_encoder.transform(["[CLS]"] + x + ["[SEP]"]).astype(np.int32) for x in data] #upper 'O', not 0
output = np.zeros((len(data), seq_length))
for i in range(len(data)):
idx = 0
for j in range(seq_length):
if valid_positions[i][j] == 1:
output[i][j] = data[i][idx]
idx += 1
return output
def inverse_transform(self, model_output_3d, valid_position):
## model_output_3d is the predicted slots output of trained model
seq_length = valid_position.shape[1]
slots = np.argmax(model_output_3d, axis=-1)
slots = [self.label_encoder.inverse_transform(y) for y in slots]
output = []
for i in range(len(slots)):
y = []
for j in range(seq_length):
if valid_position[i][j] == 1: ## only valid_positions = 1 have the real slot-tag
y.append(str(slots[i][j]))
output.append(y)
return output
def load(self):
pass
def save(self):
pass
if __name__ == '__main__':
train_tags_str_arr = ['O O B-X B-Y', 'O B-Y O']
val_tags_str_arr = ['O O B-X B-Y', 'O B-Y O XXX']
valid_positions = | np.array([[1, 1, 1, 1, 0, 1, 1], [1, 1, 0, 1, 1, 0, 1]]) | numpy.array |
"""
Unit testing for the hessian directory.
"""
from unittest import TestCase
import numpy as np
from fitbenchmarking.cost_func.nlls_cost_func import NLLSCostFunc
from fitbenchmarking.cost_func.weighted_nlls_cost_func import\
WeightedNLLSCostFunc
from fitbenchmarking.cost_func.hellinger_nlls_cost_func import\
HellingerNLLSCostFunc
from fitbenchmarking.cost_func.poisson_cost_func import\
PoissonCostFunc
from fitbenchmarking.hessian.analytic_hessian import Analytic
from fitbenchmarking.hessian.numdifftools_hessian import Numdifftools
from fitbenchmarking.hessian.scipy_hessian import Scipy
from fitbenchmarking.jacobian.analytic_jacobian import Analytic\
as JacobianClass
from fitbenchmarking.hessian.hessian_factory import create_hessian
from fitbenchmarking.parsing.fitting_problem import FittingProblem
from fitbenchmarking.utils import exceptions
from fitbenchmarking.utils.options import Options
def f_ls(x, p1, p2):
"""
Test function for numerical Hessians, to
be used with nlls cost functions
"""
return (x*(p1+p2)**2)**2
def J_ls(x, p):
"""
Analyic Jacobian evaluation of f_ls
"""
return np.column_stack((4*x**2*(p[0]+p[1])**3,
4*x**2*(p[0]+p[1])**3))
def H_ls(x, p):
"""
Analyic Hessian evaluation of f_ls
"""
return np.array([[12*x**2*(p[0]+p[1])**2, 12*x**2*(p[0]+p[1])**2],
[12*x**2*(p[0]+p[1])**2, 12*x**2*(p[0]+p[1])**2], ])
def grad2_r_nlls(x, p):
"""
Calculate 2nd partial derivatives of residuals (y-f_ls)
for nlls cost function
"""
return np.array([[-12*x**2*(p[0]+p[1])**2, -12*x**2*(p[0]+p[1])**2],
[-12*x**2*(p[0]+p[1])**2, -12*x**2*(p[0]+p[1])**2], ])
def grad2_r_weighted_nlls(x, e, p):
"""
Calculate 2nd partial derivatives of residuals (y-f_ls)/e
for weighted nlls cost function
"""
return np.array([[-12*x**2*(p[0]+p[1])**2/e, -12*x**2*(p[0]+p[1])**2/e],
[-12*x**2*(p[0]+p[1])**2/e, -12*x**2*(p[0]+p[1])**2/e], ])
def grad2_r_hellinger(x):
"""
Calculate 2nd partial derivatives of residuals (sqrt(y)-sqrt(f_ls))
for hellinger nlls cost function
"""
return np.array([[-2*x, -2*x], [-2*x, -2*x], ])
def f_poisson(x, p1, p2):
"""
Test function for numerical Hessians, to
be used with poisson cost function
"""
return p1*np.exp(p2*x)
def J_poisson(x, p):
"""
Analyic Jacobian evaluation of f_poisson
"""
return np.column_stack((np.exp(p[1]*x),
p[0]*x*np.exp(p[1]*x)))
def H_poisson(x, p):
"""
Analyic Hessian evaluation of f_poisson
"""
return np.array([[np.zeros(x.shape[0]),
x*np.exp((x*p[1]))],
[x*np.exp((x*p[1])),
p[0]*x**2*np.exp((x*p[1]))], ])
def grad2_r_poisson(x, y, p):
"""
Calculate 2nd partial derivatives of residuals
(y(log(y)-log(f_poisson))-(y-f_poisson))
for poisson cost function
"""
return np.array([[y/p[0]**2,
x* | np.exp(p[1]*x) | numpy.exp |
Subsets and Splits