prompt
stringlengths 19
879k
| completion
stringlengths 3
53.8k
| api
stringlengths 8
59
|
|---|---|---|
from __future__ import print_function
from __future__ import absolute_import
from __future__ import unicode_literals
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import ScalarFormatter, FormatStrFormatter
from matplotlib.path import Path
import matplotlib.patches as patches
##############################################
# PLOTTING FUNCTIONS FOR WIDGETS
##############################################
def fcn_FDEM_InductionSpherePlaneWidget(xtx,ytx,ztx,m,orient,x0,y0,z0,a,sig,mur,xrx,yrx,zrx,logf,Comp,Phase):
sig = 10**sig
f = 10**logf
fvec = np.logspace(0,8,41)
xmin, xmax, dx, ymin, ymax, dy = -30., 30., 0.3, -30., 30., 0.4
X,Y = np.mgrid[xmin:xmax+dx:dx, ymin:ymax+dy:dy]
X = np.transpose(X)
Y = np.transpose(Y)
Obj = SphereFEM(m,orient,xtx,ytx,ztx)
Hx,Hy,Hz,Habs = Obj.fcn_ComputeFrequencyResponse(f,sig,mur,a,x0,y0,z0,X,Y,zrx)
Hxi,Hyi,Hzi,Habsi = Obj.fcn_ComputeFrequencyResponse(fvec,sig,mur,a,x0,y0,z0,xrx,yrx,zrx)
fig1 = plt.figure(figsize=(17,6))
Ax1 = fig1.add_axes([0.04,0,0.43,1])
Ax2 = fig1.add_axes([0.6,0,0.4,1])
if Comp == 'x':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Hx,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Hxi,Comp)
elif Comp == 'y':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Hy,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Hyi,Comp)
elif Comp == 'z':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Hz,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Hzi,Comp)
elif Comp == 'abs':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Habs,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Habsi,Comp)
plt.show(fig1)
def fcn_FDEM_InductionSphereProfileWidget(xtx,ztx,m,orient,x0,z0,a,sig,mur,xrx,zrx,logf,Flag):
sig = 10**sig
f = 10**logf
if orient == "Vert. Coaxial":
orient = 'x'
elif orient == "Horiz. Coplanar":
orient = 'z'
# Same global functions can be used but with ytx, y0, yrx, Y = 0.
fvec = np.logspace(0,8,41)
xmin, xmax, dx, zmin, zmax, dz = -30., 30., 0.3, -40., 20., 0.4
X,Z = np.mgrid[xmin:xmax+dx:dx, zmin:zmax+dz:dz]
X = np.transpose(X)
Z = np.transpose(Z)
Obj = SphereFEM(m,orient,xtx,0.,ztx)
Hxi,Hyi,Hzi,Habsi = Obj.fcn_ComputeFrequencyResponse(fvec,sig,mur,a,x0,0.,z0,xrx,0.,zrx)
Hxf,Hyf,Hzf = fcn_ComputePrimary(m,orient,xtx,0.,ztx,x0,0.,z0)
fig1 = plt.figure(figsize=(17,6))
Ax1 = fig1.add_axes([0.04,0,0.38,1])
Ax2 = fig1.add_axes([0.6,0,0.4,1])
Ax1 = plotProfileTxRxSphere(Ax1,xtx,ztx,x0,z0,a,xrx,zrx,X,Z,orient)
if Flag == 'Hp':
Hpx,Hpy,Hpz = fcn_ComputePrimary(m,orient,xtx,0.,ztx,X,0.,Z)
Ax1 = plotProfileTxRxArrow(Ax1,x0,z0,Hxf,Hzf,Flag)
Ax1 = plotProfileXZplane(Ax1,X,Z,Hpx,Hpz,Flag)
elif Flag == 'Hs_real':
Hx,Hy,Hz,Habs = Obj.fcn_ComputeFrequencyResponse(f,sig,mur,a,x0,0.,z0,X,0.,Z)
Chi = fcn_ComputeExcitation_FEM(f,sig,mur,a)
Ax1 = plotProfileTxRxArrow(Ax1,x0,z0,np.real(Chi)*Hxf,np.real(Chi)*Hzf,Flag)
Ax1 = plotProfileXZplane(Ax1,X,Z,np.real(Hx),np.real(Hz),Flag)
elif Flag == 'Hs_imag':
Hx,Hy,Hz,Habs = Obj.fcn_ComputeFrequencyResponse(f,sig,mur,a,x0,0.,z0,X,0.,Z)
Chi = fcn_ComputeExcitation_FEM(f,sig,mur,a)
Ax1 = plotProfileTxRxArrow(Ax1,x0,z0,np.imag(Chi)*Hxf,np.imag(Chi)*Hzf,Flag)
Ax1 = plotProfileXZplane(Ax1,X,Z,np.imag(Hx),np.imag(Hz),Flag)
if orient == 'x':
Ax2 = plotResponseFEM(Ax2,f,fvec,Hxi,orient)
elif orient == 'z':
Ax2 = plotResponseFEM(Ax2,f,fvec,Hzi,orient)
plt.show(fig1)
def fcn_FDEM_InductionSphereProfileEM31Widget(xtx,ztx,L,m,orient,x0,z0,a,sig,mur,logf,Flag):
xtx = xtx - L/2
xrx = xtx + L
zrx = ztx
sig = 10**sig
f = 10**logf
if orient == "Vert. Coaxial":
orient = 'x'
elif orient == "Horiz. Coplanar":
orient = 'z'
# Same global functions can be used but with ytx, y0, yrx, Y = 0.
fvec = np.logspace(0,8,41)
xmin, xmax, dx, zmin, zmax, dz = -30., 30., 0.3, -40., 20., 0.4
X,Z = np.mgrid[xmin:xmax+dx:dx, zmin:zmax+dz:dz]
X = np.transpose(X)
Z = np.transpose(Z)
Obj = SphereFEM(m,orient,xtx,0.,ztx)
Hxi,Hyi,Hzi,Habsi = Obj.fcn_ComputeFrequencyResponse(fvec,sig,mur,a,x0,0.,z0,xrx,0.,zrx)
Hxf,Hyf,Hzf = fcn_ComputePrimary(m,orient,xtx,0.,ztx,x0,0.,z0)
fig1 = plt.figure(figsize=(17,6))
Ax1 = fig1.add_axes([0.04,0,0.38,1])
Ax2 = fig1.add_axes([0.6,0,0.4,1])
Ax1 = plotProfileTxRxSphere(Ax1,xtx,ztx,x0,z0,a,xrx,zrx,X,Z,orient)
if Flag == 'Hp':
Hpx,Hpy,Hpz = fcn_ComputePrimary(m,orient,xtx,0.,ztx,X,0.,Z)
Ax1 = plotProfileTxRxArrow(Ax1,x0,z0,Hxf,Hzf,Flag)
Ax1 = plotProfileXZplane(Ax1,X,Z,Hpx,Hpz,Flag)
elif Flag == 'Hs_real':
Hx,Hy,Hz,Habs = Obj.fcn_ComputeFrequencyResponse(f,sig,mur,a,x0,0.,z0,X,0.,Z)
Chi = fcn_ComputeExcitation_FEM(f,sig,mur,a)
Ax1 = plotProfileTxRxArrow(Ax1,x0,z0,np.real(Chi)*Hxf,np.real(Chi)*Hzf,Flag)
Ax1 = plotProfileXZplane(Ax1,X,Z,np.real(Hx),np.real(Hz),Flag)
elif Flag == 'Hs_imag':
Hx,Hy,Hz,Habs = Obj.fcn_ComputeFrequencyResponse(f,sig,mur,a,x0,0.,z0,X,0.,Z)
Chi = fcn_ComputeExcitation_FEM(f,sig,mur,a)
Ax1 = plotProfileTxRxArrow(Ax1,x0,z0,np.imag(Chi)*Hxf,np.imag(Chi)*Hzf,Flag)
Ax1 = plotProfileXZplane(Ax1,X,Z,np.imag(Hx),np.imag(Hz),Flag)
if orient == 'x':
Ax2 = plotResponseFEM(Ax2,f,fvec,Hxi,orient)
elif orient == 'z':
Ax2 = plotResponseFEM(Ax2,f,fvec,Hzi,orient)
plt.show(fig1)
##############################################
# GLOBAL FUNTIONS
##############################################
def fcn_ComputeExcitation_FEM(f,sig,mur,a):
"""Compute Excitation Factor (FEM)"""
w = 2*np.pi*f
mu = 4*np.pi*1e-7*mur
alpha = a*np.sqrt(1j*w*mu*sig)
chi = 1.5*(2*mur*(np.tanh(alpha) - alpha) + (alpha**2*np.tanh(alpha) - alpha + np.tanh(alpha)))/(mur*(np.tanh(alpha) - alpha) - (alpha**2*np.tanh(alpha) - alpha + np.tanh(alpha)))
return chi
def fcn_ComputePrimary(m,orient,xtx,ytx,ztx,X,Y,Z):
"""Computes Inducing Field at Sphere"""
R = np.sqrt((X-xtx)**2 + (Y-ytx)**2 + (Z-ztx)**2)
if orient == "x":
Hpx = (1/(4*np.pi))*(3*m*(X-xtx)*(X-xtx)/R**5 - m/R**3)
Hpy = (1/(4*np.pi))*(3*m*(Y-ytx)*(X-xtx)/R**5)
Hpz = (1/(4*np.pi))*(3*m*(Z-ztx)*(X-xtx)/R**5)
elif orient == "y":
Hpx = (1/(4*np.pi))*(3*m*(X-xtx)*(Y-ytx)/R**5)
Hpy = (1/(4*np.pi))*(3*m*(Y-ytx)*(Y-ytx)/R**5 - m/R**3)
Hpz = (1/(4*np.pi))*(3*m*(Z-ztx)*(Y-ytx)/R**5)
elif orient == "z":
Hpx = (1/(4*np.pi))*(3*m*(X-xtx)*(Z-ztx)/R**5)
Hpy = (1/(4*np.pi))*(3*m*(Y-ytx)*(Z-ztx)/R**5)
Hpz = (1/(4*np.pi))*(3*m*(Z-ztx)*(Z-ztx)/R**5 - m/R**3)
return Hpx, Hpy, Hpz
##############################################
# GLOBAL PLOTTING FUNTIONS
##############################################
def plotAnomalyXYplane(Ax,f,X,Y,Z,H,Comp,Phase):
FS = 20
if Phase == 'Real':
H = np.real(H)
Str = "Re("
Str_title = "Real Component of "
elif Phase == 'Imag':
H = np.imag(H)
Str = "Im("
Str_title = "Imaginary Component of "
tol = 1e5
Sign = np.sign(H)
H = np.abs(H)
MAX = np.max(H)
H = np.log10(tol*H/MAX)
Sign[H<0] = 0.
H[H<0] = 0.
Cmap = 'viridis'
#Cmap = 'seismic_r'
if Comp == 'abs':
TickLabels = MAX*np.array([1.,1e-1,1e-2,1e-3,1e-4,0.,-1e-4,-1e-3,-1e-2,-1e-1,-1])
TickLabels = ["%.1e" % x for x in TickLabels]
Cplot = Ax.contourf(X,Y,Sign*H,50,cmap=Cmap, vmin=-5, vmax=5)
cbar = plt.colorbar(Cplot, ax=Ax, pad=0.02, ticks=-np.linspace(-5,5,11))
else:
TickLabels = MAX*np.array([-1.,-1e-1,-1e-2,-1e-3,-1e-4,0.,1e-4,1e-3,1e-2,1e-1,1])
TickLabels = ["%.1e" % x for x in TickLabels]
Cplot = Ax.contourf(X,Y,Sign*H,50,cmap=Cmap, vmin=-5, vmax=5)
cbar = plt.colorbar(Cplot, ax=Ax, pad=0.02, ticks=np.linspace(-5,5,11))
if Comp == 'x':
cbar.set_label(Str+'$\mathbf{Hx}$) [A/m]', rotation=270, labelpad = 25, size=FS+4)
Ax.set_title(Str_title + "$\mathbf{Hx}$",fontsize=FS+6)
elif Comp == 'y':
cbar.set_label(Str+'$\mathbf{Hy}$) [A/m]', rotation=270, labelpad = 25, size=FS+4)
Ax.set_title(Str_title + "$\mathbf{Hy}$",fontsize=FS+6)
elif Comp == 'z':
cbar.set_label(Str+'$\mathbf{Hz}$) [A/m]', rotation=270, labelpad = 25, size=FS+4)
Ax.set_title(Str_title + "$\mathbf{Hz}$",fontsize=FS+6)
elif Comp == 'abs':
cbar.set_label(Str+'$\mathbf{|H|}$) [A/m]', rotation=270, labelpad = 25, size=FS+4)
Ax.set_title(Str_title + "$\mathbf{|H|}$",fontsize=FS+6)
cbar.set_ticklabels(TickLabels)
cbar.ax.tick_params(labelsize=FS-2)
Ax.set_xbound(np.min(X),np.max(X))
Ax.set_ybound(np.min(Y),np.max(Y))
Ax.set_xlabel('X [m]',fontsize=FS+2)
Ax.set_ylabel('Y [m]',fontsize=FS+2,labelpad=-10)
Ax.tick_params(labelsize=FS-2)
return Ax
def plotPlaceTxRxSphereXY(Ax,xtx,ytx,xrx,yrx,x0,y0,a):
Xlim = Ax.get_xlim()
Ylim = Ax.get_ylim()
FS = 20
Ax.scatter(xtx,ytx,s=100,color='k')
Ax.text(xtx-0.75,ytx+1.5,'$\mathbf{Tx}$',fontsize=FS+6)
Ax.scatter(xrx,yrx,s=100,color='k')
Ax.text(xrx-0.75,yrx-4,'$\mathbf{Rx}$',fontsize=FS+6)
xs = x0 + a*np.cos(np.linspace(0,2*np.pi,41))
ys = y0 + a*np.sin(np.linspace(0,2*np.pi,41))
Ax.plot(xs,ys,ls=':',color='k',linewidth=3)
Ax.set_xbound(Xlim)
Ax.set_ybound(Ylim)
return Ax
def plotResponseFEM(Ax,fi,f,H,Comp):
FS = 20
xTicks = (np.logspace(np.log(np.min(f)),np.log(np.max(f)),9))
Ylim = np.array([np.min(np.real(H)),np.max(np.real(H))])
Ax.grid('both', linestyle='-', linewidth=0.8, color=[0.8, 0.8, 0.8])
Ax.semilogx(f,0*f,color='k',linewidth=2)
Ax.semilogx(f,np.real(H),color='k',linewidth=4,label="Real")
Ax.semilogx(f,np.imag(H),color='k',linewidth=4,ls='--',label="Imaginary")
Ax.semilogx(np.array([fi,fi]),1.1*Ylim,linewidth=3,color='r')
Ax.set_xbound(np.min(f),np.max(f))
Ax.set_ybound(1.1*Ylim)
Ax.set_xlabel('Frequency [Hz]',fontsize=FS+2)
Ax.tick_params(labelsize=FS-2)
Ax.yaxis.set_major_formatter(FormatStrFormatter('%.1e'))
if Comp == 'x':
Ax.set_ylabel('$\mathbf{Hx}$ [A/m]',fontsize=FS+4,labelpad=-5)
Ax.set_title('$\mathbf{Hx}$ Response at $\mathbf{Rx}$',fontsize=FS+6)
elif Comp == 'y':
Ax.set_ylabel('$\mathbf{Hy}$ [A/m]',fontsize=FS+4,labelpad=-5)
Ax.set_title('$\mathbf{Hy}$ Response at $\mathbf{Rx}$',fontsize=FS+6)
elif Comp == 'z':
Ax.set_ylabel('$\mathbf{Hz}$ [A/m]',fontsize=FS+4,labelpad=-5)
Ax.set_title('$\mathbf{Hz}$ Response at $\mathbf{Rx}$',fontsize=FS+6)
elif Comp == 'abs':
Ax.set_ylabel('$\mathbf{|H|}$ [A/m]',fontsize=FS+4,labelpad=-5)
Ax.set_title('$\mathbf{|H|}$ Response at $\mathbf{Rx}$',fontsize=FS+6)
if np.max(np.real(H[-1])) > 0.:
handles, labels = Ax.get_legend_handles_labels()
Ax.legend(handles, labels, loc='upper left', fontsize=FS)
elif np.max(np.real(H[-1])) < 0.:
handles, labels = Ax.get_legend_handles_labels()
Ax.legend(handles, labels, loc='lower left', fontsize=FS)
return Ax
def plotProfileTxRxSphere(Ax,xtx,ztx,x0,z0,a,xrx,zrx,X,Z,orient):
FS = 22
phi = | np.linspace(0,2*np.pi,41) | numpy.linspace |
import pytest
import awesomediff as ad
import numpy as np
### Test uni_Newton
def test_uni_Newton_func():
def root_finding(a):
return a**2 + 2*a + 1
root = ad.uni_Newton(root_finding, 100, max_iter=100, epsilon=1e-06)
y_val = root_finding(root)
assert (np.isclose(y_val, 0, atol=1e-06))
def root_finding(a): #function with no root
return a**2 + 2*a + 2
root = ad.uni_Newton(root_finding, 100) #reach max iteration, and return none
assert root is None
def root_finding(a): #bad starting point: derivative = 0
return -a**2 + 1
root = ad.uni_Newton(root_finding, 0) #return None
assert root is None
def root_finding(a):
return ad.sin(a)
root = ad.uni_Newton(root_finding, 3, max_iter=100, epsilon=1e-08)
y_val = root_finding(root)
assert (np.isclose(y_val.val, 0, atol=1e-07))
#check input format
with pytest.raises(ValueError):
ad.uni_Newton(root_finding, 's')
def root_finding(a,b): #function with two inputs
return a**2 + 2*a + 2
with pytest.raises(ValueError):
ad.uni_Newton(root_finding, 3)
def test_helpers():
# Check inputs:
X = [[1,2],[3,4]]
y1 = [[1,2]]
y2 = [1,2,3]
with pytest.raises(AssertionError):
X,y = ad.solvers._check_inputs(X,y2)
# Transpose:
M = [[1,2,3],[4,5,6]]
Mt = ad.transpose(M,check=True)
assert Mt == [[1,4],[2,5],[3,6]]
# Mean and variance:
assert ad.mean([1,2,3,4,5])== | np.mean([1,2,3,4,5]) | numpy.mean |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2018 <NAME> <<EMAIL>>
#
# Distributed under terms of the MIT license.
"""
trajOptMultiPhaseCollocationProblem.py
This class implements methods for solving problem with multiple phases.
I will also change code style to suppress those warnings.
"""
from __future__ import division
import numpy as np
from .trajOptBase import LinearPointObj as linearPointObj
from .trajOptBase import LinearPointConstr as linearPointConstr
from .trajOptBase import NonLinearPointObj as nonLinearPointObj, NonLinearObj as nonLinearObj
from .trajOptBase import NonLinearPointConstr as nonLinearPointConstr, NonLinearConstr as nonLinearConstr
from .trajOptBase import AddX as addX
from pyoptsolver import OptProblem, OptResult as result
from .utility import random_gen_in_bound as randomGenInBound
from scipy.sparse import coo_matrix, csr_matrix
from .trajOptCollocationProblem import TrajOptCollocProblem
class NonLinearConnectConstr(object):
"""Class for defining point constraint function.
:currentmodule:
.. automethod:: __callg__
.. exclude-members:: find_time_gradient
"""
def __init__(self, phase1, phase2, nc, lb=None, ub=None, nG=None, index1=-1, index2=0, addx_index=None):
"""Constructor for nonlinear point constraint. Also serve as path constraint.
:param phase1/phase2: int, phase number that constraint is imposed. We read data from them
:param nc: int, dimension of constraint function
:param lb, ub: lower and upper bound of the constraint function. None means equal to 0
:param nG: int, number of nnz of Jacobian
:param index1/index2: int, by default we connect last point of phase 1 with first point of phase 2. However, we allow manual assignment of them.
:param addx_index: int, which additional x we use to connect those two phases
"""
self.phases = (phase1, phase2)
self.indexes = (index1, index2)
self.nf = nc
self.nG = nG
self.human = False # if we call __callhumang__ instead of __callg__
self.autonomous = (False, False)
self.timeindex = (None, None)
self.addx_index = addx_index
if lb is None:
self.lb = np.zeros(self.nf)
else:
self.lb = lb
if ub is None:
self.ub = np.zeros(self.nf)
else:
self.ub = ub
def __callg__(self, x1, x2, F, G, row, col, rec, needg, addx=None):
"""Call and evaluate the constraint function. x1 and x2 are points in phase 1 and phase 2.
I return them together in G, row, col since it might be derived from sympy so thay are together.
But, human derived formulas love the previous one better
"""
raise NotImplementedError
def __callhumang__(self, x1, x2, needg, addx=None):
"""Call and evaluate the constraint function. x1 and x2 are points in phase 1 and phase 2.
I return them together in G, row, col since it might be derived from sympy so thay are together.
But, human derived formulas love the previous one better
:param x1: ndarray, a (t, x, u, p) tuple from phase 1
:param x2: ndarray, a (t, x, u, p) tuple from phase 2
:param needg: if we return those G, too
:param addx: additional parameters passed in
:return F: where constraint functions are evaluated and stored
:return G1, G2, G3: Jacobian of F w.r.t x1, x2, and optionally addx (G3 empty if addx is None)
"""
raise NotImplementedError
def find_time_gradient(self, x1, x2, addx=None):
"""Find where the gradients are w.r.t time."""
if self.human:
rvalue = self.__callhumang__(x1, x2, True, addx)
if self.addxindex is None:
F, G1, G2, = rvalue
if self.nG is None:
self.nG = G1.nnz + G2.nnz
else:
F, G1, G2, Ga = rvalue
if self.nG is None:
self.nG = G1.nnz + G2.nnz + Ga.nnz
tindex1 = np.where(G1.col == 0)[0]
tindex2 = np.where(G2.col == 0)[0]
else:
tmpy = np.zeros(self.nf)
tmpG = np.zeros(self.nG)
tmprow = np.zeros(self.nG, dtype=int)
tmpcol = np.zeros(self.nG, dtype=int)
self.__callg__(x1, x2, tmpy, tmpG, tmprow, tmpcol, True, True, addx)
len1 = len(x1)
tindex1 = np.where(tmpcol == 0)[0]
tindex2 = np.where(tmpcol == len1)[0]
auto1 = len(tindex1) == 0
auto2 = len(tindex2) == 0
self.timeindex = (tindex1, tindex2)
self.autonomous = (auto1, auto2)
if self.lb is None:
self.lb = np.zeros(self.nf)
if self.ub is None:
self.ub = np.zeros(self.nf)
class LinearConnectConstr(object):
"""Class for defining linear constraint functions.
:currentmodule:
.. exclude-members:: find_time_gradient
"""
def __init__(self, phase1, phase2, a1, a2, lb=None, ub=None, index1=-1, index2=0, adda=None, addx_index=None):
"""Constructor for linear point constraint. Also serve as path constraint.
:param phase1/phase2: int, phase number that constraint is imposed. We read data from them
:param a1/a2: ndarray, the constraint, :math: `l \le A_1 x_1 + A_2 x_2 \le u`
:param lb/ub: lower and upper bound of the constraint function. None means equal to 0
:param index1/index2: int, by default we connect last point of phase 1 with first point of phase 2. However, we allow manual assignment of them.
:param adda: ndarray, if additional parameter comes into play, we use this
:param addx_index: int, index of the additional parameters
"""
self.phases = (phase1, phase2)
self.indexes = (index1, index2)
assert a1.shape[0] == a2.shape[0]
self.a = (coo_matrix(a1), coo_matrix(a2)) # since everything is in pair
self.nf = a1.shape[0]
self.adda = coo_matrix(adda)
self.addx_index = addx_index
self.find_time_gradient()
if lb is None:
self.lb = | np.zeros(self.nf) | numpy.zeros |
import os
import numpy as np
import pyro
import pyro.distributions as dist
import torch
import torch.nn as nn
from anndata import AnnData
from pyro import clear_param_store
from pyro.infer.autoguide import AutoNormal, init_to_mean
from pyro.nn import PyroModule, PyroSample
from scvi import _CONSTANTS
from scvi.data import register_tensor_from_anndata, synthetic_iid
from scvi.dataloaders import AnnDataLoader
from scvi.model.base import (
BaseModelClass,
PyroJitGuideWarmup,
PyroSampleMixin,
PyroSviTrainMixin,
)
from scvi.module.base import PyroBaseModuleClass
from scvi.train import PyroTrainingPlan, Trainer
class BayesianRegressionPyroModel(PyroModule):
def __init__(self, in_features, out_features, per_cell_weight=False):
super().__init__()
self.in_features = in_features
self.out_features = out_features
self.n_obs = None
self.per_cell_weight = per_cell_weight
self.register_buffer("zero", torch.tensor(0.0))
self.register_buffer("one", torch.tensor(1.0))
self.register_buffer("ten", torch.tensor(10.0))
self.linear = PyroModule[nn.Linear](in_features, out_features)
self.linear.weight = PyroSample(
lambda prior: dist.Normal(self.zero, self.one)
.expand([self.out_features, self.in_features])
.to_event(2)
)
self.linear.bias = PyroSample(
lambda prior: dist.Normal(self.zero, self.ten)
.expand([self.out_features])
.to_event(1)
)
def create_plates(self, x, y, ind_x):
"""
Function for creating plates is needed when using AutoGuides.
Should have the same call signature as model.
"""
return pyro.plate("obs_plate", size=self.n_obs, dim=-2, subsample=ind_x)
def list_obs_plate_vars(self):
"""
Model annotation for minibatch training with pyro plate.
A dictionary with:
1. "name" - the name of observation/minibatch plate;
2. "in" - indexes of model args to provide to encoder network when using amortised inference;
3. "sites" - dictionary with
keys - names of variables that belong to the observation plate (used to recognise
and merge posterior samples for minibatch variables)
values - the dimensions in non-plate axis of each variable (used to construct output
layer of encoder network when using amortised inference)
"""
return {
"name": "obs_plate",
"in": [0], # model args index for expression data
"sites": {"per_cell_weights": 1},
}
@staticmethod
def _get_fn_args_from_batch(tensor_dict):
x = tensor_dict[_CONSTANTS.X_KEY]
y = tensor_dict[_CONSTANTS.LABELS_KEY]
ind_x = tensor_dict["ind_x"].long().squeeze()
return (x, y, ind_x), {}
def forward(self, x, y, ind_x):
obs_plate = self.create_plates(x, y, ind_x)
sigma = pyro.sample("sigma", dist.Exponential(self.one))
mean = self.linear(x).squeeze(-1)
if self.per_cell_weight:
with obs_plate:
per_cell_weights = pyro.sample(
"per_cell_weights", dist.Normal(self.zero, self.one)
)
mean = mean + per_cell_weights.squeeze(-1)
with obs_plate:
pyro.sample("obs", dist.Normal(mean, sigma), obs=y)
return mean
class BayesianRegressionModule(PyroBaseModuleClass):
def __init__(self, **kwargs):
super().__init__()
self._model = BayesianRegressionPyroModel(**kwargs)
self._guide = AutoNormal(
self.model, init_loc_fn=init_to_mean, create_plates=self.model.create_plates
)
self._get_fn_args_from_batch = self._model._get_fn_args_from_batch
@property
def model(self):
return self._model
@property
def guide(self):
return self._guide
@property
def list_obs_plate_vars(self):
return self.model.list_obs_plate_vars()
class BayesianRegressionModel(PyroSviTrainMixin, PyroSampleMixin, BaseModelClass):
def __init__(
self,
adata: AnnData,
per_cell_weight=False,
):
# in case any other model was created before that shares the same parameter names.
clear_param_store()
# add index for each cell (provided to pyro plate for correct minibatching)
adata.obs["_indices"] = np.arange(adata.n_obs).astype("int64")
register_tensor_from_anndata(
adata,
registry_key="ind_x",
adata_attr_name="obs",
adata_key_name="_indices",
)
super().__init__(adata)
self.module = BayesianRegressionModule(
in_features=adata.shape[1],
out_features=1,
per_cell_weight=per_cell_weight,
)
self._model_summary_string = "BayesianRegressionModel"
self.init_params_ = self._get_init_params(locals())
def test_pyro_bayesian_regression(save_path):
use_gpu = int(torch.cuda.is_available())
adata = synthetic_iid()
# add index for each cell (provided to pyro plate for correct minibatching)
adata.obs["_indices"] = np.arange(adata.n_obs).astype("int64")
register_tensor_from_anndata(
adata,
registry_key="ind_x",
adata_attr_name="obs",
adata_key_name="_indices",
)
train_dl = AnnDataLoader(adata, shuffle=True, batch_size=128)
pyro.clear_param_store()
model = BayesianRegressionModule(in_features=adata.shape[1], out_features=1)
plan = PyroTrainingPlan(model)
plan.n_obs_training = len(train_dl.indices)
trainer = Trainer(
gpus=use_gpu,
max_epochs=2,
)
trainer.fit(plan, train_dl)
if use_gpu == 1:
model.cuda()
# test Predictive
num_samples = 5
predictive = model.create_predictive(num_samples=num_samples)
for tensor_dict in train_dl:
args, kwargs = model._get_fn_args_from_batch(tensor_dict)
_ = {
k: v.detach().cpu().numpy()
for k, v in predictive(*args, **kwargs).items()
if k != "obs"
}
# test save and load
# cpu/gpu has minor difference
model.cpu()
quants = model.guide.quantiles([0.5])
sigma_median = quants["sigma"][0].detach().cpu().numpy()
linear_median = quants["linear.weight"][0].detach().cpu().numpy()
model_save_path = os.path.join(save_path, "model_params.pt")
torch.save(model.state_dict(), model_save_path)
pyro.clear_param_store()
new_model = BayesianRegressionModule(in_features=adata.shape[1], out_features=1)
# run model one step to get autoguide params
try:
new_model.load_state_dict(torch.load(model_save_path))
except RuntimeError as err:
if isinstance(new_model, PyroBaseModuleClass):
plan = PyroTrainingPlan(new_model)
plan.n_obs_training = len(train_dl.indices)
trainer = Trainer(
gpus=use_gpu,
max_steps=1,
)
trainer.fit(plan, train_dl)
new_model.load_state_dict(torch.load(model_save_path))
else:
raise err
quants = new_model.guide.quantiles([0.5])
sigma_median_new = quants["sigma"][0].detach().cpu().numpy()
linear_median_new = quants["linear.weight"][0].detach().cpu().numpy()
| np.testing.assert_array_equal(sigma_median_new, sigma_median) | numpy.testing.assert_array_equal |
import os
import torch
from skimage import io, transform
import numpy as np
import h5py
from torch.utils.data import Dataset, DataLoader
import imgaug as ia
from sklearn.model_selection import StratifiedKFold
from torchvision import transforms
import cv2
root_dir = '/data1/trinh/data/patches_data/SBP/Colon_Dataset/COLON_PATCHES_1000_V2'
train_root1 = root_dir + '/train_data/v1'
train_root2 = root_dir + '/train_data/wsi'
valid_root1 = root_dir + '/valid_data/v1'
valid_root2 = root_dir + '/valid_data/wsi'
train_root = root_dir + '/train_data'
valid_root = root_dir + '/valid_data'
class ToTensor(object):
"""
This is a transform(augmentation)class
convert ndarrays in sample to Tensors
"""
# swap color axis because
# input : numpy image: H x W x C
# output: torch image: C X H X W
def __call__(self, image):
image = image.transpose((2, 0, 1))
return torch.from_numpy(image)
def read_colon_dataset():
# make whole dataset list
# input : root that path
# output : x_whole, y_whole that contains all file paths and classes each
train_x, train_y = [], []
valid_x, valid_y = [], []
for(path, dir, filenames) in os.walk(train_root):
for filename in filenames:
file_path = os.path.join(path, filename)
# if path[-3:] == 'wsi':
# y_class = 0
# else:
# y_class = int(file_path[-5])
y_class = int(file_path[-5])
train_x.append(file_path)
train_y.append(y_class)
for(path, dir, filenames) in os.walk(valid_root):
for filename in filenames:
file_path = os.path.join(path, filename)
y_class = int(file_path[-5])
valid_x.append(file_path)
valid_y.append(y_class)
print('LOADED DATA')
print('---------# train_data : {}\n'
'benign class : {}\n'
'cancer1 : {}\n'
'cancer2 : {}\n'
'cancer3 : {}\n'
'---------# valid_data : {}\n'
'benign class : {}\n'
'cancer1 : {}\n'
'cancer2 : {}\n'
'cancer3 : {}\n'.format(
len(train_x), np.sum(np.asarray(train_y)==0),
np.sum(np.asarray(train_y) == 1),
np.sum(np.asarray(train_y) == 2)
,np.sum(np.asarray(train_y)==3),
len(valid_x), np.sum(np.asarray(valid_y) == 0),
np.sum(np.asarray(valid_y) == 1),
np.sum(np.asarray(valid_y) == 2)
, np.sum(np.asarray(valid_y) == 3),
)
)
train_x = np.array(train_x)
train_y = np.array(train_y)
valid_x = np.array(valid_x)
valid_y = np.array(valid_y)
for i in range(0,4):
if i == 2:
pass
else:
num_dup = int(round(np.sum(train_y == 2) / np.sum(train_y == i)))
idx = np.where(train_y == i)
data = train_x[idx]
labels = train_y[idx]
for num in range(num_dup-1):
train_x = | np.concatenate([train_x, data]) | numpy.concatenate |
# -*- coding: utf-8 -*-
"""
This module provides many types of image augmentation. One can choose appropriate augmentation for
detection, segmentation and classification.
"""
import cv2
import numpy
import random
class Augmentor(object):
"""
All augmentation operations are static methods of this class.
"""
def __init__(self):
pass
@staticmethod
def histogram_equalisation(image):
"""
do histogram equlisation for grayscale image
:param image: input image with single channel 8bits
:return: processed image
"""
if image.ndim != 2:
print('Input image is not grayscale!')
return None
if image.dtype != numpy.uint8:
print('Input image is not uint8!')
return None
result = cv2.equalizeHist(image)
return result
@staticmethod
def grayscale(image):
"""
convert BGR image to grayscale image
:param image: input image with BGR channels
:return:
"""
if image.ndim != 3:
return None
if image.dtype != numpy.uint8:
print('Input image is not uint8!')
return None
result = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
return result
@staticmethod
def inversion(image):
"""
invert the image (255-)
:param image: input image with BGR or grayscale
:return:
"""
if image.dtype != numpy.uint8:
print('Input image is not uint8!')
return None
result = 255 - image
return result
@staticmethod
def binarization(image, block_size=5, C=10):
"""
convert input image to binary image
cv2.adaptiveThreshold is used, for detailed information, refer to opencv docs
:param image:
:return:
"""
if image.ndim == 3:
image_grayscale = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
else:
image_grayscale = image
binary_image = cv2.adaptiveThreshold(image_grayscale, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY, block_size, C)
return binary_image
@staticmethod
def brightness(image, min_factor=0.5, max_factor=1.5):
'''
adjust the image brightness
:param image:
:param min_factor:
:param max_factor:
:return:
'''
if image.dtype != numpy.uint8:
print('Input image is not uint8!')
return None
factor = numpy.random.uniform(min_factor, max_factor)
result = image * factor
if factor > 1:
result[result > 255] = 255
result = result.astype(numpy.uint8)
return result
@staticmethod
def saturation(image, min_factor=0.5, max_factor=1.5):
'''
adjust the image saturation
:param image:
:param min_factor:
:param max_factor:
:return:
'''
if image.dtype != numpy.uint8:
print('Input image is not uint8!')
return None
image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
factor = | numpy.random.uniform(min_factor, max_factor) | numpy.random.uniform |
"""
runs using
1) python/3.3.2 2) numpy/1.11.1/python/3.3 3) scipy/0.17.1/python/3.3
module load python3/3.3.2 /scratch/mhess/py3p3/3.3
Aim: do MOR steady state solver with efficient matrices
"""
import numpy as np
import time
from ITHACA_SEM_code import ROM_Oseen_Iteration_step
from ITHACA_SEM_code import Generate_Advection_Terms
from ITHACA_SEM_code import ROM_Oseen_Iteration_step
def remove_from_matrix(matrix, columns, rows):
return [
[float(matrix[row_num][col_num])
for col_num in range(len(matrix[row_num]))
if not col_num in columns]
for row_num in range(len(matrix))
if not row_num in rows]
#(Dbnd, Dint, sing_A, sing_B, sing_Btilde, sing_C, M_trafo_no_pp_incl_dbc) = gen_Mats_cav.gen()
def Oseen_Iteration(mu_vec, Dbnd, Dint, sing_A, sing_B, sing_Btilde, sing_C, M_trafo_no_pp_incl_dbc, glodofphys, LocGloMapMatA, LocGloSign, LocGloMap, snap, ngc, nlc, bmap, imap, num_elem, nsize_bndry, nsize_int, nsize_p, nvel, c_f_bnd, c_f_p, c_f_int, NumDirBCs, nGlobHomBndDofs, no_loc_dbc, elem_loc_dbc, no_not_loc_dbc, elem_not_loc_dbc, IP, IPp, bwdtrans, cartmap0, cartmap1, LocGloBndSign, LocGloBndMap, BndCondCoeffsToGlobalCoeffsMap , init_bnd, forcing):
print("snap.shape ", snap.shape)
snap_x = snap[:, 0:ngc]
snap_y = snap[:, ngc:2*ngc]
print("snap_x.shape ", snap_x.shape)
print("snap_y.shape ", snap_y.shape)
snap_x_mean = np.mean(snap_x, axis=0)
snap_y_mean = np.mean(snap_y, axis=0)
nbmap = bmap.shape[0]
nimap = imap.shape[0]
nbnd = nbmap
nint = nimap
nsize_bndry_p1 = nsize_bndry + 1
nsize_p_m1 = nsize_p - 1
u_x = snap_x_mean
u_y = snap_y_mean
supr_f_bnd = np.dot( np.transpose(Dbnd) , c_f_p )
supr_f_int = np.dot( np.transpose(Dint) , c_f_p )
c_f_all = np.r_[c_f_bnd, c_f_p, c_f_int]
(c_f_all, R1, R2) = np.linalg.svd(c_f_all, full_matrices=False)
c_f_all = c_f_all[:, 0:np.max(np.where(np.cumsum(R1)/np.sum(R1) < .99))+1]
c_f_bnd = c_f_all[0:c_f_bnd.shape[0],:]
c_f_p = c_f_all[c_f_bnd.shape[0]:c_f_bnd.shape[0]+c_f_p.shape[0],:]
c_f_int = c_f_all[c_f_bnd.shape[0]+c_f_p.shape[0]:c_f_bnd.shape[0]+c_f_p.shape[0]+c_f_int.shape[0],:]
print("c_f_bnd.shape ", c_f_bnd.shape)
print("c_f_p.shape ", c_f_p.shape)
print("c_f_int.shape ", c_f_int.shape)
nBndDofs = nGlobHomBndDofs + NumDirBCs
nGlobBndDofs = nBndDofs
no_of_dbc_in_loc = no_loc_dbc
loc_dbc_set = elem_loc_dbc
RBsize = c_f_bnd.shape[1]
V_f_bnd = np.zeros([num_elem*nsize_bndry - no_of_dbc_in_loc, c_f_bnd.shape[1]])
cropped_counter = 0
for i in range(0, num_elem*nsize_bndry):
if i not in loc_dbc_set:
V_f_bnd[cropped_counter,:] = c_f_bnd[i,:]
cropped_counter = cropped_counter + 1
V_f_p = c_f_p
V_f_int = c_f_int
f_bnd_dbc = 0*np.arange((num_elem*nsize_bndry - no_not_loc_dbc)*1.0)
non_cropped_counter = 0
for i in range(0,num_elem*nsize_bndry):
if i in loc_dbc_set:
f_bnd_dbc[non_cropped_counter] = c_f_bnd[i,0]
non_cropped_counter += 1
t = time.time()
sing_A_M = np.dot(np.transpose(M_trafo_no_pp_incl_dbc),sing_A)
sing_A_MM = np.dot(M_trafo_no_pp_incl_dbc,sing_A_M)
Dbnd_M = np.dot(Dbnd, M_trafo_no_pp_incl_dbc)
Dbnd_MM = np.dot(Dbnd_M, np.transpose(M_trafo_no_pp_incl_dbc))
sing_B_M = np.dot(np.transpose(M_trafo_no_pp_incl_dbc),sing_B)
sing_B_MM = np.dot(M_trafo_no_pp_incl_dbc,sing_B_M)
sing_A_MM_cropped = np.array(remove_from_matrix(sing_A_MM, loc_dbc_set, loc_dbc_set))
sing_A_MM_Aud = np.array(remove_from_matrix(sing_A_MM, elem_not_loc_dbc, loc_dbc_set))
Dbnd_crop = np.array(remove_from_matrix(Dbnd, loc_dbc_set, set()))
sing_Dbnd_Aud = np.array(remove_from_matrix(Dbnd, elem_not_loc_dbc, set()))
sing_B_MM_cropped = np.array(remove_from_matrix(sing_B_MM, set(), loc_dbc_set))
Dbnd_MM_crop = np.array(remove_from_matrix(Dbnd_MM, loc_dbc_set, set()))
sing_Btilde_cropped = np.array(remove_from_matrix(sing_Btilde, set(), loc_dbc_set))
sing_Btilde_Aud = np.array(remove_from_matrix(sing_Btilde, set(), elem_not_loc_dbc))
A_11_1 = np.dot(np.dot(np.transpose(V_f_bnd), sing_A_MM_cropped), V_f_bnd)
A_21_alt = -np.dot(np.dot(np.transpose(V_f_p), Dbnd_crop), V_f_bnd)
A_31_1 = np.dot(np.dot(np.transpose(V_f_int), np.transpose(sing_Btilde_cropped)), V_f_bnd)
A_12_alt = -np.dot(np.dot(np.transpose(V_f_bnd), np.transpose(Dbnd_MM_crop)), V_f_p)
A_32_alt = -np.dot(np.dot(np.transpose(V_f_int), np.transpose(Dint)), V_f_p)
A_13_1 = np.dot(np.dot(np.transpose(V_f_bnd), sing_B_MM_cropped), V_f_int)
A_23_alt = np.transpose(A_32_alt)
A_33_1 = np.dot(np.dot(np.transpose(V_f_int), sing_C), V_f_int)
r1_1 = np.dot(np.dot(np.transpose(V_f_bnd), sing_A_MM_Aud), f_bnd_dbc)
r2_1 = -np.dot(np.dot(np.transpose(V_f_p), sing_Dbnd_Aud), f_bnd_dbc)
r3_1 = np.dot(np.dot(np.transpose(V_f_int), np.transpose(sing_Btilde_Aud)), f_bnd_dbc)
Dbnd_M = np.dot(Dbnd, M_trafo_no_pp_incl_dbc)
Dbnd_MM = np.dot(Dbnd_M, | np.transpose(M_trafo_no_pp_incl_dbc) | numpy.transpose |
'''Module to plot '''
import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
import scipy.sparse as scp
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
import numpy as np
import os, sqlite3, pickle, sys, gzip, shutil, time
import os.path as osp
from pandas import read_sql, concat
from sklearn.preprocessing import normalize, RobustScaler
from sklearn.neighbors import kneighbors_graph as knn
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
from spektral.data import Dataset, Graph
import tensorflow as tf
features = ["dom_x", "dom_y", "dom_z", "time", "charge_log10"]
# features = ["dom_x", "dom_y", "dom_z", "dom_time", "charge_log10"]
targets = ["energy_log10", "zenith","azimuth"]
import warnings
warnings.filterwarnings("ignore")
# %matplotlib inline
def inspect(event=0, muon=True, event_no=None, n_neighbors=20, angle=45, save=False, degree=False, hist=False, transform_path='../db_files/MuonGun/transformers.pkl', db_path='../db_files/MuonGun/rasmus_classification_muon_3neutrino_3mio.db'):
'''Plot a graph in 3d, where the colour is determined by time and the size of the point is determined by charge.
Generally, the only thing you need to do is modify the file path to the db_file in load_event.
Inspect takes an integer (as just event number x in the database), if not given a specific event_no, which is then loaded in.
angle specifies the initial angle (azimuthal) to see the plot from. If you plot with matplotlib notebook you can control the angle.
degree: if True we colour based on node degree and not ti,e
hist: if true distributions of node features are shown.
save should be self-explanatory.'''
dt=load_event(event, event_no, db_path=db_path, n_neighbors=n_neighbors, transform_path=transform_path, muon=muon)[0]
X, A, Y=dt.x, dt.a, dt.y
if hist:
fig1, ax1=plt.subplots(nrows=1, ncols=5, figsize=(10,4))
for i in range(len(X[0])):
ax1[i].hist(X[:,i], histtype='step')
ax1[i].set(xlabel=features[i], yscale='log')
fig1.tight_layout()
ix, iy,_=scp.find(A)
adj=list(zip(ix,iy))
G=nx.Graph()
for i in np.arange(len(X[:,0])):
G.add_node(i, x=X[i,0], y=X[i,1], z=X[i,2], t=X[i,3], q=X[i,4], pos2d=[X[i,0], X[i,1]] ,pos3d=[X[i,0], X[i,1],X[i,2]])
G.add_edges_from(adj)
plot_3d(G, Y, angle=angle, save=save, degree=degree)
def plot_3d(G,Y, angle=45, save=False, degree=False):
# Get node positions
pos = nx.get_node_attributes(G, 'pos3d')
ts = nx.get_node_attributes(G, 't')
qs = nx.get_node_attributes(G, 'q')
# Get number of nodes
n = G.number_of_nodes()
# Get the maximum number of edges adjacent to a single node
edge_max = max([G.degree(i) for i in range(n)])
# Define color range proportional to number of edges adjacent to a single node
mint=min(ts.items(), key=lambda x: x[1])[1]
maxt=max(ts.items(), key=lambda x: x[1])[1]
# print(mint, ts.items())
tlist=[np.log(t)-np.log(mint) for key, t in ts.items()]
tlist=[(t-mint)/(maxt-mint) for key, t in ts.items()]
# tlist=[np.log(t-mint)-np.log(maxt-mint) for key, t in ts.items()]
colors=plt.cm.plasma(tlist)
if degree:
colors = [plt.cm.plasma(G.degree(i)/edge_max) for i in range(n)] #if centrality
# 3D network plot
central=np.array(list(nx.degree_centrality(G).values()))
connect=nx.is_connected(G)
# print(colors)
with plt.style.context(('ggplot')):
fig = plt.figure(figsize=(10,7))
ax = Axes3D(fig)
# Loop on the pos dictionary to extract the x,y,z coordinates of each node
for key, value in pos.items():
xi = value[0]
yi = value[1]
zi = value[2]
# Scatter plot
mapa=ax.scatter(xi, yi, zi, c=[colors[key]], s=50+10**(4*qs[key]), edgecolors='k', alpha=0.7)
# print(50+10*10**(2*qs[key]))
# Loop on the list of edges to get the x,y,z, coordinates of the connected nodes
# Those two points are the extrema of the line to be plotted
for i,j in enumerate(G.edges()):
x = | np.array((pos[j[0]][0], pos[j[1]][0])) | numpy.array |
"""Tests for the :class:`AssertionManager<assertionlib.manager.AssertionManager>` class."""
from typing import Optional
import pytest
from assertionlib import assertion
try:
import numpy as np
NUMPY_EX: Optional[Exception] = None
except Exception as ex:
NUMPY_EX = ex
def test_abs() -> None:
"""Test :meth:`AssertionManager.abs`."""
assertion.abs(5)
assertion.abs(5)
assertion.abs(0, invert=True)
assertion.abs(5, 6, 7, 8, exception=TypeError)
assertion.abs([], exception=TypeError)
def test_add() -> None:
"""Test :meth:`AssertionManager.add`."""
assertion.add(5, 5)
assertion.add(0, 0, invert=True)
assertion.add(5, 6, 7, 8, exception=TypeError)
assertion.add([], 5, exception=TypeError)
def test_and() -> None:
"""Test :meth:`AssertionManager.and_`."""
assertion.and_(5, 5)
assertion.and_(0, 5, invert=True)
assertion.and_(0, 0, invert=True)
assertion.and_(5, 6, 7, 8, exception=TypeError)
def test_concat() -> None:
"""Test :meth:`AssertionManager.concat`."""
assertion.concat([1], [2])
assertion.concat([], [], invert=True)
assertion.concat([], {}, exception=TypeError)
assertion.concat(5, 6, exception=TypeError)
assertion.concat([], [], [], exception=TypeError)
def test_contains() -> None:
"""Test :meth:`AssertionManager.contains`."""
assertion.contains([1], 1)
assertion.contains({1}, 1)
assertion.contains({1: None}, 1)
assertion.contains([1], 2, invert=True)
assertion.contains([1], 5, 6, 7, exception=TypeError)
assertion.contains(5, 5, exception=TypeError)
def test_countof() -> None:
"""Test :meth:`AssertionManager.countOf`."""
assertion.countOf([1, 1, 1], 1)
assertion.countOf([1, 1, 1], 2, invert=True)
assertion.countOf([1], 5, 6, 7, exception=TypeError)
assertion.countOf(5, 5, exception=TypeError)
def test_eq() -> None:
"""Test :meth:`AssertionManager.eq`."""
assertion.eq(5, 5)
assertion.eq(5, 6, invert=True)
assertion.eq(5, 6, 7, 8, exception=TypeError)
def test_floordiv() -> None:
"""Test :meth:`AssertionManager.floordiv`."""
assertion.floordiv(5, 1)
assertion.floordiv(5, 5)
assertion.floordiv(0.5, 5, invert=True)
assertion.floordiv(0, 5, invert=True)
assertion.floordiv(5, 0, exception=ZeroDivisionError)
assertion.floordiv(5, 6, 7, 8, exception=TypeError)
assertion.floordiv([1], 5, exception=TypeError)
def test_ge() -> None:
"""Test :meth:`AssertionManager.ge`."""
assertion.ge(6, 5)
assertion.ge(5, 5)
assertion.ge(5, 6, invert=True)
assertion.ge(5, 6, 7, 8, exception=TypeError)
assertion.ge([], 6, exception=TypeError)
def test_getitem() -> None:
"""Test :meth:`AssertionManager.getitem`."""
assertion.getitem([1], 0)
assertion.getitem([0], 0, invert=True)
assertion.getitem(5, 6, 7, 8, exception=TypeError)
assertion.getitem(5, 6, exception=TypeError)
assertion.getitem([1], 5, exception=IndexError)
assertion.getitem({1: None}, 5, exception=KeyError)
def test_gt() -> None:
"""Test :meth:`AssertionManager.gt`."""
assertion.gt(6, 5)
assertion.gt(5, 6, invert=True)
assertion.gt(6, 6, invert=True)
assertion.gt(5, 6, 7, 8, exception=TypeError)
assertion.gt([], 6, exception=TypeError)
def test_index() -> None:
"""Test :meth:`AssertionManager.index`."""
assertion.index(6)
assertion.index(0, invert=True)
assertion.index(5, 6, 7, 8, exception=TypeError)
assertion.index(5.0, exception=TypeError)
def test_inv() -> None:
"""Test :meth:`AssertionManager.inv`."""
assertion.inv(6)
assertion.inv(-1, invert=True)
assertion.inv(5, 6, 7, 8, exception=TypeError)
assertion.inv(5.0, exception=TypeError)
def test_invert() -> None:
"""Test :meth:`AssertionManager.invert`."""
assertion.invert(6)
assertion.invert(-1, invert=True)
assertion.invert(5, 6, 7, 8, exception=TypeError)
assertion.invert(5.0, exception=TypeError)
def test_is() -> None:
"""Test :meth:`AssertionManager.is_`."""
a = 5
b = 6
assertion.is_(a, a)
assertion.is_(a, b, invert=True)
assertion.is_(a, a, a, a, a, exception=TypeError)
def test_is_not() -> None:
"""Test :meth:`AssertionManager.is_not`."""
a = 5
b = 6
assertion.is_not(a, b)
assertion.is_not(a, a, invert=True)
assertion.is_not(a, a, a, a, a, exception=TypeError)
def test_le() -> None:
"""Test :meth:`AssertionManager.le`."""
assertion.le(5, 6)
assertion.le(5, 5)
assertion.le(6, 5, invert=True)
assertion.le(5, 6, 7, 8, exception=TypeError)
assertion.le([], 6, exception=TypeError)
def test_lshift() -> None:
"""Test :meth:`AssertionManager.lshift`."""
assertion.lshift(5, 6)
assertion.lshift(0, 5, invert=True)
assertion.lshift(0, 0, invert=True)
assertion.lshift(-5, 6)
assertion.lshift(-5, -6, exception=ValueError)
assertion.lshift(5, -6, exception=ValueError)
assertion.lshift(5, 6, 7, 8, exception=TypeError)
assertion.lshift([], 6, exception=TypeError)
def test_lt() -> None:
"""Test :meth:`AssertionManager.lt`."""
assertion.lt(5, 6)
assertion.lt(6, 5, invert=True)
assertion.lt(6, 6, invert=True)
assertion.lt(5, 6, 7, 8, exception=TypeError)
assertion.lt([], 6, exception=TypeError)
@pytest.mark.skipif(bool(NUMPY_EX), reason=str(NUMPY_EX))
def test_matmul() -> None:
"""Test :meth:`AssertionManager.matmul`."""
assertion.matmul( | np.ones(2) | numpy.ones |
import os
import gym
import tensorflow as tf
import numpy as np
import argparse
from tqdm import tqdm
from common.atari_env_wrapper import Atari
from common.exploration_scheduler import ExplorationExploitationScheduler
from common.frame_processor import FrameProcessor
from common.utils import clip_reward, update_min_max_frame
from DQN.replay import ReplayMemory
from DQN.network import DQN
PARSER = argparse.ArgumentParser(description=None)
PARSER.add_argument('-t', '--train', default=False, type=bool, help='Train : True, Evaluate : False')
PARSER.add_argument('-env', '--environment', default='EnduroDeterministic-v4', type=str, help='Atari Environment to run')
PARSER.add_argument('-max_ep_len', '--MAX_EPISODE_LENGTH', default=100000, type=int, help='Maximum episode length')
PARSER.add_argument('-save_freq', '--SAVE_FREQUENCY', default=1000000, type=int, help='Number of frames the agent sees between evaluations')
PARSER.add_argument('-netw_freq', '--NETW_UPDATE_FREQ', default=10000, type=int, help='Number of chosen actions between updating the target network.')
PARSER.add_argument('-g', '--DISCOUNT_FACTOR', default=0.99, type=float, help='gamma in the Bellman equation')
PARSER.add_argument('-start_learn', '--REPLAY_MEMORY_START_SIZE', default=50000, type=int, help='Number of completely random actions before agent starts learning')
PARSER.add_argument('-max_step', '--MAX_FRAMES', default=25000000, type=int, help='Total number of frames the agent sees')
PARSER.add_argument('-mem_size', '--MEMORY_SIZE', default=1000000, type=int, help='Number of transitions stored in the replay memory')
PARSER.add_argument('-num_noop', '--NO_OP_STEPS', default=30, type=int, help='Number of NOOP or FIRE actions at the beginning of an episode')
PARSER.add_argument('-upd_freq', '--UPDATE_FREQ', default=4, type=int, help='Number of actions a gradient descent step is performed')
PARSER.add_argument('-hidden', '--HIDDEN', default=512, type=int, help='Number of neurons in the final layer')
PARSER.add_argument('-lr', '--LEARNING_RATE', default=0.0000625, type=float, help='Learning rate')
PARSER.add_argument('-bs', '--BS', default=32, type=int, help='Batch size')
PARSER.add_argument('-path', '--PATH', default="output/", type=str, help='Gifs and checkpoints will be saved here')
PARSER.add_argument('-sum', '--SUMMARIES', default="summaries", type=str, help='logdir for tensorboard')
PARSER.add_argument('-id', '--RUNID', default='run_1', type=str, help='run id inside logdir')
PARSER.add_argument('-n', '--NOISY', default=False, type=bool, help='If Parameter noise included')
PARSER.add_argument('-state_dependent', '--STATE_DEPENDENT', default=False, type=bool, help='If variance is state dependent : Default all parameters independent variance')
PARSER.add_argument('-single', '--SINGLE', default=False, type=bool, help='Change to single variance for all noises: Works only with state dependent noise')
PARSER.add_argument('-layer', '--LAYERWISE', default=False, type=bool, help='Change to layer wise common variance: Works only with state dependent noise')
PARSER.add_argument('-nls', '--NOISY_LATENT_SIZE', default=16, type=int, help='Latent size for noise')
PARSER.add_argument('-no_eps', '--NO_EPSILON_GREEDY', default=False, type=bool, help='Disable epsilon greedy')
PARSER.add_argument('-eps_sched', '--EPS_SCHED', default=False, type=bool, help='Greedier epsilon schedule')
PARSER.add_argument('-switch_noise_init', '--SWITCH_NOISY_LAYER_INIT', default=1, type=int, help='Switch Noisy layer init to variance scaling initializer')
PARSER.add_argument('-d', '--DEVICE', default='gpu', type=str, help='GPU/CPU')
PARSER.add_argument('-d_id', '--DEVICE_ID', default=-1, type=int, help='GPU id to use')
PARSER.add_argument('-lm', '--LOAD_MODEL', default=False, type=bool, help='Enable to load existing model')
PARSER.add_argument('-lbs', '--LOAD_BUFFER_SIZE', default=50000, type=int, help='Enable to load existing model')
PARSER.add_argument('-exp_stop', '--EXP_STOP', default=np.inf, type=int, help='Stop parameter noise')
PARSER.add_argument('-greedy', '--GREEDY', default=False, type=bool, help='Greedy Agent')
PARSER.add_argument('-save_buffer', '--SAVE_BUFFER', default=False, type=bool, help='Set flag to True to enable saving replay_buffer')
PARSER.add_argument('-load_buffer', '--LOAD_BUFFER', default=False, type=bool, help='Set flag to True to enable loading replay_buffer')
PARSER.add_argument('-add_q_values_to_perturb', '--ADD_Q_VALUES_TO_PERTURB', default=False, type=bool, help='Set flag to True to add Q values as input to perturbation module')
PARSER.add_argument('-use_defaults', '--USE_DEFAULTS', default=False, type=bool, help='Set flag to True run with default settings (Do not add other flags except for train/evaluate and the environment to be trained')
PARSER.add_argument('-eps_greedy', '--EPS_GREEDY_AGENT', default=False, type=bool, help='Set flag to True to train/evaluate an epsilon greedy agent')
PARSER.add_argument('-noisy_net', '--NOISY_NET_AGENT', default=False, type=bool, help='Set flag to True to train/evaluate a NoisyNet agent')
PARSER.add_argument('-sane', '--SANE_AGENT', default=False, type=bool, help='Set flag to True to train/evaluate a SANE agent')
PARSER.add_argument('-q_sane', '--Q_SANE_AGENT', default=False, type=bool, help='Set flag to True to train/evaluate a Q-SANE agent')
PARSER.add_argument('-eval_steps', '--EVAL_STEPS', default=500000, type=int, help='Number of interactions to evaluate an agent')
PARSER.add_argument('-lambda1', '--LAMBDA1', default=0.0001, type=float, help='Number of interactions to evaluate an agent')
PARSER.add_argument('-lambda2', '--LAMBDA2', default=0.01, type=float, help='Number of interactions to evaluate an agent')
PARSER.add_argument('-add_var_loss', '--ADD_VAR_LOSS', default=False, type=bool, help='Number of interactions to evaluate an agent')
ARGS = PARSER.parse_args()
EPS_G_SCHEDULE = ARGS.EPS_SCHED
TRAIN = ARGS.train
ENV_NAME = ARGS.environment
MAX_EPISODE_LENGTH = ARGS.MAX_EPISODE_LENGTH
SAVE_FREQUENCY = ARGS.SAVE_FREQUENCY
NETW_UPDATE_FREQ = ARGS.NETW_UPDATE_FREQ
DISCOUNT_FACTOR =ARGS.DISCOUNT_FACTOR
REPLAY_MEMORY_START_SIZE = ARGS.REPLAY_MEMORY_START_SIZE
MAX_FRAMES = ARGS.MAX_FRAMES
MEMORY_SIZE = ARGS.MEMORY_SIZE
NO_OP_STEPS = ARGS.NO_OP_STEPS
UPDATE_FREQ = ARGS.UPDATE_FREQ
HIDDEN = ARGS.HIDDEN
LEARNING_RATE = ARGS.LEARNING_RATE
BS = ARGS.BS
PATH = ARGS.RUNID + "_" + ARGS.PATH
SUMMARIES = ARGS.SUMMARIES
RUNID = ARGS.RUNID
NOISY=ARGS.NOISY
STATE_DEPENDENT=ARGS.STATE_DEPENDENT
SINGLE_VARIANCE=ARGS.SINGLE
LAYERWISE_VARIANCE = ARGS.LAYERWISE
NOISY_LATENT_SIZE = ARGS.NOISY_LATENT_SIZE
NO_EPS = ARGS.NO_EPSILON_GREEDY
SWITCH_NOISY_LAYER_INIT = ARGS.SWITCH_NOISY_LAYER_INIT
DEVICE = ARGS.DEVICE
LAMBDA1 = ARGS.LAMBDA1
LAMBDA2 = ARGS.LAMBDA2
ADD_VAR_LOSS = ARGS.ADD_VAR_LOSS
if ARGS.DEVICE_ID == -1 :
DEVICE_ID =0
else :
os.environ["CUDA_VISIBLE_DEVICES"] = str(ARGS.DEVICE_ID)
DEVICE_ID =0
os.makedirs(PATH, exist_ok=True)
os.makedirs(os.path.join(SUMMARIES, RUNID), exist_ok=True)
SUMM_WRITER = tf.summary.FileWriter(os.path.join(SUMMARIES, RUNID))
LOAD_MODEL = ARGS.LOAD_MODEL
LOAD_BUFFER_SIZE = ARGS.LOAD_BUFFER_SIZE
EXP_STOP = ARGS.EXP_STOP
GREEDY = ARGS.GREEDY
SAVE_BUFFER = ARGS.SAVE_BUFFER
LOAD_BUFFER = ARGS.LOAD_BUFFER
ADD_Q_VALUES_TO_PERTURB = ARGS.ADD_Q_VALUES_TO_PERTURB
if ARGS.USE_DEFAULTS :
if ARGS.EPS_GREEDY_AGENT :
SWITCH_NOISY_LAYER_INIT = 2
elif ARGS.NOISY_NET_AGENT :
SWITCH_NOISY_LAYER_INIT = 3
NOISY = True
NO_EPS = True
elif ARGS.SANE_AGENT or ARGS.Q_SANE_AGENT :
SWITCH_NOISY_LAYER_INIT = 2
NOISY = True
STATE_DEPENDENT = True
SINGLE_VARIANCE = True
NO_EPS = True
NOISY_LATENT_SIZE = 256
if ARGS.Q_SANE_AGENT :
ADD_Q_VALUES_TO_PERTURB = True
def learn(session, replay_memory, main_dqn, target_dqn, batch_size, gamma, frame_number, is_double_q = False):
"""
Args:
session: A tensorflow sesson object
replay_memory: A ReplayMemory object
main_dqn: A DQN object
target_dqn: A DQN object
batch_size: Integer, Batch size
gamma: Float, discount factor for the Bellman equation
frame_number: Frame Number to check whether to stop parameter space noise
Returns:
loss: The loss of the minibatch
"""
states, actions, rewards, new_states, terminal_flags = replay_memory.get_minibatch()
if frame_number - NETW_UPDATE_FREQ > EXP_STOP :
target_cond_variable = False
else :
target_cond_variable = True
if frame_number > EXP_STOP :
main_cond_variable = False
else :
main_cond_variable = True
if ADD_Q_VALUES_TO_PERTURB :
dict_inp = {
target_dqn.q_val_input : np.zeros([batch_size,target_dqn.n_actions]),
main_dqn.q_val_input : np.zeros([batch_size,main_dqn.n_actions]),
target_dqn.input : new_states,
main_dqn.input : states,
target_dqn.cond_variable:[target_cond_variable],
main_dqn.cond_variable:[main_cond_variable]}
main_q_for_perturb, target_q_for_perturb = session.run([main_dqn.q_values, target_dqn.q_values], feed_dict=dict_inp)
inp_pert_dict = {main_dqn.q_val_input : main_q_for_perturb, target_dqn.q_val_input: target_q_for_perturb}
else :
inp_pert_dict = {}
q_vals, arg_q_max = session.run([target_dqn.q_values, target_dqn.best_action], feed_dict={**{target_dqn.input:new_states, target_dqn.cond_variable:[target_cond_variable]}, **inp_pert_dict})
double_q = q_vals[range(batch_size), arg_q_max]
target_q = rewards + (gamma*double_q * (1-terminal_flags))
loss_grad_list = session.run([main_dqn.loss_q_act, main_dqn.update],
feed_dict={**{main_dqn.input:states,
main_dqn.target_q:target_q,
main_dqn.cond_variable:[main_cond_variable],
main_dqn.action:actions}, **inp_pert_dict})
return loss_grad_list[0]
class TargetNetworkUpdater(object):
def __init__(self, main_dqn_vars, target_dqn_vars):
self.main_dqn_vars = main_dqn_vars
self.target_dqn_vars = target_dqn_vars
def _update_target_vars(self):
update_ops = []
for i, var in enumerate(self.main_dqn_vars):
copy_op = self.target_dqn_vars[i].assign(var.value())
update_ops.append(copy_op)
return update_ops
def __call__(self, sess):
"""
Args:
sess: A Tensorflow session object
Assigns the values of the parameters of the main network to the
parameters of the target network
"""
update_ops = self._update_target_vars()
for copy_op in update_ops:
sess.run(copy_op)
tf.reset_default_graph()
atari = Atari(ENV_NAME, NO_OP_STEPS)
print("The environment has the following {} actions: {}".format(atari.env.action_space.n,
atari.env.unwrapped.get_action_meanings()))
# main DQN and target DQN networks:
with tf.device("/{}:{}".format(DEVICE,DEVICE_ID)) :
with tf.variable_scope('mainDQN'):
MAIN_DQN = DQN(scope='mainDQN',
n_actions=atari.env.action_space.n,
hidden=HIDDEN,
learning_rate=LEARNING_RATE,
switch_init=SWITCH_NOISY_LAYER_INIT,
noisy = NOISY,
layer_wise_variance=LAYERWISE_VARIANCE,
single_param=SINGLE_VARIANCE,
state_dependent=STATE_DEPENDENT,
noise_latent_size=NOISY_LATENT_SIZE,
add_q_values_perturb_module = ADD_Q_VALUES_TO_PERTURB, lambda1=LAMBDA1, lambda2=LAMBDA2, add_var_loss=ADD_VAR_LOSS)
with tf.variable_scope('targetDQN'):
TARGET_DQN = DQN(scope='targetDQN',
n_actions=atari.env.action_space.n,
hidden=HIDDEN,
switch_init=SWITCH_NOISY_LAYER_INIT,
noisy = NOISY,
layer_wise_variance=LAYERWISE_VARIANCE,
single_param=SINGLE_VARIANCE,
state_dependent=STATE_DEPENDENT,
noise_latent_size=NOISY_LATENT_SIZE,
add_q_values_perturb_module = ADD_Q_VALUES_TO_PERTURB)
init = tf.global_variables_initializer()
saver = tf.train.Saver(max_to_keep=50)
best_model_saver = tf.train.Saver(max_to_keep=50)
MAIN_DQN_VARS = tf.trainable_variables(scope='mainDQN')
TARGET_DQN_VARS = tf.trainable_variables(scope='targetDQN')
# Scalar summaries for tensorboard: loss, average reward and evaluation score
with tf.name_scope('Performance'):
LOSS_PH = tf.placeholder(tf.float32, shape=None, name='loss_summary')
LOSS_SUMMARY = tf.summary.scalar('loss', LOSS_PH)
REWARD_PH = tf.placeholder(tf.float32, shape=None, name='reward_summary')
REWARD_SUMMARY = tf.summary.scalar('reward', REWARD_PH)
AVG_SIGMA_PH = tf.placeholder(tf.float32, shape=None, name='avg_sigma_summary')
AVG_SIGMA_SUMMARY = tf.summary.scalar('avg_sigma', AVG_SIGMA_PH)
MIN_SIGMA_PH = tf.placeholder(tf.float32, shape=None, name='min_sigma_summary')
MIN_SIGMA_SUMMARY = tf.summary.scalar('min_sigma', MIN_SIGMA_PH)
MAX_SIGMA_PH = tf.placeholder(tf.float32, shape=None, name='max_sigma_summary')
MAX_SIGMA_SUMMARY = tf.summary.scalar('max_sigma', MAX_SIGMA_PH)
ACTION_DIFF_PH = tf.placeholder(tf.float32, shape=None, name='diff_action_summary')
ACTION_DIFF_SUMMARY = tf.summary.scalar('diff_action', ACTION_DIFF_PH)
PERFORMANCE_SUMMARIES = tf.summary.merge([LOSS_SUMMARY, REWARD_SUMMARY, AVG_SIGMA_SUMMARY, MIN_SIGMA_SUMMARY, MAX_SIGMA_SUMMARY, ACTION_DIFF_SUMMARY])
# Histogramm summaries for tensorboard: parameters
with tf.name_scope('Parameters'):
ALL_PARAM_SUMMARIES = []
for var in MAIN_DQN_VARS:
with tf.name_scope('mainDQN/'):
MAIN_DQN_KERNEL = tf.summary.histogram(str(var.name).replace("/", "_"), tf.reshape(var, shape=[-1]))
ALL_PARAM_SUMMARIES.extend([MAIN_DQN_KERNEL])
PARAM_SUMMARIES = tf.summary.merge(ALL_PARAM_SUMMARIES)
def train(session, my_replay_memory, explore_exploit_sched, update_networks, episode_start, frame_number_start):
"""
Trains a DQN agent
Args:
session: A tensorflow sesson object
replay_memory: A ReplayMemory object
explore_exploit_sched: An ExplorationExploitationScheduler object, Determines an action according to an epsilon greedy/noisy strategy
update_networks: A TargetNetworkUpdater object, updates the target network periodically
episode_start: Integer, episodes elapsed before this function is called
frame_number_start: Integer, frames elapsed before this function is called
"""
with session as sess:
frame_number = frame_number_start
rewards = []
diff_action_list = []
loss_list = []
episodes = episode_start
max_sigmas_to_keep = 10
while frame_number < MAX_FRAMES:
epoch_frame = 0
while epoch_frame < SAVE_FREQUENCY:
terminal_life_lost = atari.reset(sess)
episode_reward_sum = 0
diff_action = 0.0
episode_step = 0
small_sigmas = []
large_sigmas = []
min_sigma_frames = []
min_sigma_states = []
max_sigma_frames = []
max_sigma_states = []
all_sigmas = []
for _ in range(MAX_EPISODE_LENGTH):
curr_frame = atari.curr_frame
currr_state = atari.state
if NOISY :
feed_dict = {}
if ADD_Q_VALUES_TO_PERTURB :
feed_dict[explore_exploit_sched.DQN.q_val_input] = np.zeros([1, explore_exploit_sched.DQN.n_actions])
action_no_noise, _, q_values = explore_exploit_sched.get_action(sess, frame_number, atari.state, no_noise=True, other_args=feed_dict)
if ADD_Q_VALUES_TO_PERTURB and NOISY :
feed_dict = {explore_exploit_sched.DQN.q_val_input : q_values}
else :
feed_dict = {}
action, sigma, _ = explore_exploit_sched.get_action(sess, frame_number, atari.state, other_args=feed_dict)
episode_step +=1
min_sigma_frames, max_sigma_frames, small_sigmas, large_sigmas, max_sigma_states, min_sigma_states = update_min_max_frame(all_sigmas, sigma, small_sigmas, max_sigmas_to_keep, min_sigma_frames, curr_frame, min_sigma_states, currr_state, large_sigmas, max_sigma_frames, max_sigma_states)
if NOISY and action != action_no_noise:
diff_action +=1
processed_new_frame, reward, terminal, terminal_life_lost, new_frame = atari.step(sess, action)
frame_number += 1
epoch_frame += 1
episode_reward_sum += reward
clipped_reward = clip_reward(reward)
my_replay_memory.add_experience(action=action,
frame=processed_new_frame[:, :, 0],
reward=clipped_reward,
terminal=terminal_life_lost)
if terminal and (episodes+1) %10 == 0:
small_sigmas = []
large_sigmas = []
min_sigma_frames = []
max_sigma_frames = []
max_sigma_states = []
min_sigma_states = []
if frame_number % UPDATE_FREQ == 0 and frame_number > REPLAY_MEMORY_START_SIZE:
loss_q = learn(sess, my_replay_memory, MAIN_DQN, TARGET_DQN, BS, DISCOUNT_FACTOR,frame_number)
loss_list.append(loss_q)
if frame_number % NETW_UPDATE_FREQ == 0 and frame_number > REPLAY_MEMORY_START_SIZE:
update_networks(sess)
if terminal:
terminal = False
small_sigmas = []
large_sigmas = []
min_sigma_frames = []
max_sigma_frames = []
min_sigma_states = []
break
rewards.append(episode_reward_sum)
diff_action_list.append(float(diff_action)/episode_step)
episodes +=1
if len(rewards) > 100 :
rewards.pop(0)
if episodes % 10 == 0:
print("LOSS : {} ".format(np.mean(loss_list)))
if frame_number > REPLAY_MEMORY_START_SIZE:
summ = sess.run(PERFORMANCE_SUMMARIES,
feed_dict={LOSS_PH:np.mean(loss_list),
REWARD_PH:np.mean(rewards[-100:]),
ACTION_DIFF_PH : np.mean(diff_action_list),
AVG_SIGMA_PH: np.mean(all_sigmas),
MIN_SIGMA_PH: np.min(all_sigmas),
MAX_SIGMA_PH:np.max(all_sigmas)})
if NOISY :
print("Effective exploration : {} ".format(np.mean(diff_action_list)))
diff_action_list = []
SUMM_WRITER.add_summary(summ, frame_number)
loss_list = []
# Histogramm summaries for tensorboard
summ_param = sess.run(PARAM_SUMMARIES)
SUMM_WRITER.add_summary(summ_param, frame_number)
print("Episodes {}, Frames {}, Mean Reward {} Sigma : Average {} , MIN {} , MAX {}, Exploration {} ".format(episodes,
frame_number,
np.mean(rewards[-100:]),
np.mean(np.abs(all_sigmas)),
np.min(all_sigmas),
np.max(all_sigmas),
explore_exploit_sched.eps))
with open(PATH + 'rewards_'+ RUNID+ '.dat', 'a') as reward_file:
print(episodes, frame_number,
np.mean(rewards[-100:]),np.mean(np.abs(all_sigmas)), np.min(all_sigmas), np.max(all_sigmas), explore_exploit_sched.eps, file=reward_file)
terminal = True
#Save the network parameters and buffer
saver.save(sess, PATH+'/my_model', global_step=frame_number)
print("Saved model at frame {}".format(frame_number) )
if SAVE_BUFFER :
my_replay_memory.save_buffer_to_disk(PATH+'/buffer_item_')
'''
Helper functions
get_info_from_log() : Gets information about the episodes elapsed, frames elapsed and score from the log file
load_model() : Loads a model from the mentioned checkpoint
populateExperienceReplayBuffer() : Loads the replay buffer with transitions from the loaded model
'''
def get_info_from_log() :
log_file = open(PATH + 'rewards_'+ RUNID+ '.dat', 'r')
lineList = log_file.readlines()
log_file.close()
last_log = lineList[len(lineList)-1]
last_episode, last_frame, last_score, _, _, _, _ = last_log.split(' ')
return int(last_episode) + 10, int(last_frame) + 1, float(last_score)
def load_model(sess, name):
imported_graph = tf.train.import_meta_graph(tf.train.latest_checkpoint(PATH)+'.meta')
imported_graph.restore(sess,name)
episode_start, frame_number_start, score = get_info_from_log()
print('Loaded model successfully : ' ,name)
print('Episode_start {} frame_start {} score {}'.format(episode_start, frame_number_start, score))
return episode_start, frame_number_start
def populateExperienceReplayBuffer(session, my_replay_memory, explore_exploit_sched, buffer_size):
buffer_frame_number = 0
pbar = tqdm(total=buffer_size)
while buffer_frame_number < buffer_size :
terminal_life_lost = atari.reset(session)
for _ in range(MAX_EPISODE_LENGTH):
if NOISY :
feed_dict = {}
if ADD_Q_VALUES_TO_PERTURB :
feed_dict[explore_exploit_sched.DQN.q_val_input] = | np.zeros([1, explore_exploit_sched.DQN.n_actions]) | numpy.zeros |
"""
Class definition for the Branch_and_Bound subdriver.
This pseudo-driver can only be run when plugged into the AMIEGO driver's minlp slot.
This is the branch and bound algorithm that maximizes the constrained
expected improvement function and returns an integer infill point. The
algorithm uses the relaxation techniques proposed by Jones et.al. on their
paper on EGO,1998. This enables the algorithm to use any gradient-based
approach to obtain a global solution. Also, to satisfy the integer
constraints, a new branching scheme has been implemented.
Developed by <NAME>
School of Aeronautics & Astronautics
Purdue University, West Lafayette, IN 47906
July, 2016
Implemented in OpenMDAO, Aug 2016, <NAME>
"""
from collections import OrderedDict
import os
from time import time
import numpy as np
from scipy.special import erf
from pyDOE2 import lhs
from openmdao.core.driver import Driver
from openmdao.drivers.genetic_algorithm_driver import GeneticAlgorithm
from openmdao.utils.concurrent import concurrent_eval, concurrent_eval_lb
from openmdao.utils.general_utils import set_pyoptsparse_opt
from amiego.optimize_function import snopt_opt
# check that pyoptsparse is installed
# if it is, try to use SNOPT but fall back to SLSQP
_, OPTIMIZER = set_pyoptsparse_opt('SNOPT')
class Branch_and_Bound(Driver):
"""
Class definition for the Branch_and_Bound driver.
This pseudo-driver can only be run when plugged into the AMIEGO driver's minlp slot.
This is the branch and bound algorithm that maximizes the constrained
expected improvement function and returns an integer infill point. The
algorithm uses the relaxation techniques proposed by Jones et.al. on
their paper on EGO,1998. This enables the algorithm to use any
gradient-based approach to obtain a global solution. Also, to satisfy the
integer constraints, a new branching scheme has been implemented.
Attributes
----------
dvs : list
Cache of integer design variable names.
eflag_MINLPBB : bool
This is set to True when we find a local minimum.
fopt : ndarray
Objective value at optimal design.
obj_surrogate : <AMIEGOKrigingSurrogate>
Surrogate model of the objective as a function of the integer design vars.
xI_lb : ndarray
Lower bound of the integer design variables.
xI_ub : ndarray
Upper bound of the integer design variables.
xopt : ndarray
Optimal design.
_randomstate : np.random.RandomState, int
Random state (or seed-number) which controls the seed and random draws.
"""
def __init__(self):
"""
Initialize the Branch_and_Bound driver.
"""
super(Branch_and_Bound, self).__init__()
# What we support
self.supports['inequality_constraints'] = True
self.supports['equality_constraints'] = False
self.supports['multiple_objectives'] = False
self.supports['two_sided_constraints'] = False
self.supports['active_set'] = False
self.supports['linear_constraints'] = False
self.supports['gradients'] = False
self.supports['integer_design_vars'] = True
self.dvs = []
self.i_idx_cache = {}
self.obj_surrogate = None
# We will set this to True if we have found a minimum.
self.eflag_MINLPBB = False
# Amiego retrieves optimal design and optimum upon completion.
self.xopt = None
self.fopt = None
# Experimental Options. TODO: could go into Options
self.load_balance = True
self.aggressive_splitting = False
# Random state can be set for predictability during testing
if 'SimpleGADriver_seed' in os.environ:
self._randomstate = int(os.environ['SimpleGADriver_seed'])
else:
self._randomstate = None
def _declare_options(self):
"""
Declare options before kwargs are processed in the init method.
"""
opt = self.options
opt.declare('active_tol', 1.0e-6, lower=0.0,
desc='Tolerance (2-norm) for triggering active set '
'reduction.')
opt.declare('atol', 0.1, lower=0.0,
desc='Absolute tolerance (inf-norm) of upper minus '
'lower bound for termination.')
opt.declare('con_tol', 1.0e-6, lower=0.0,
desc='Constraint thickness.')
opt.declare('disp', True,
desc='Set to False to prevent printing of iteration '
'messages.')
opt.declare('ftol', 1.0e-4, lower=0.0,
desc='Absolute tolerance for sub-optimizations.')
opt.declare('maxiter', 100000, lower=0.0,
desc='Maximum number of iterations.')
opt.declare('trace_iter', 5,
desc='Number of generations to trace back for ubd.')
opt.declare('trace_iter_max', 10,
desc='Maximum number of generations to trace back for ubd.')
opt.declare('maxiter_ubd', 10000,
desc='Number of generations ubd stays the same')
opt.declare('local_search', 0, values=[0, 1, 2],
desc='Local search type. Set to 0 for GA, 1 for LHS, 2 for LHS + SQP '
'(Default = 0)')
def run(self):
"""
Execute the Branch_and_Bound method.
Returns
-------
boolean
Failure flag; True if failed to converge, False if successful.
"""
problem = self._problem()
obj_surrogate = self.obj_surrogate
atol = self.options['atol']
disp = self.options['disp']
maxiter = self.options['maxiter']
maxiter_ubd = self.options['maxiter_ubd']
self.iter_count = 1
self.eflag_MINLPBB = False
obj_surrogate.p = 2
obj_surrogate.y_best = np.min(obj_surrogate.Y)
# ----------------------------------------------------------------------
# Step 1: Initialize
# ----------------------------------------------------------------------
num_des = len(self.xI_lb)
node_num = 0
itercount = 0
ubd_count = 0
# Initial B&B bounds are infinite.
UBD = np.inf
LBD = -np.inf
LBD_prev = -np.inf
# Copy our desvars' user specified upper and lower bounds
xL_iter = self.xI_lb.copy()
xU_iter = self.xI_ub.copy()
num_init_sam = num_des
init_sam = lhs(num_des, samples=num_init_sam, criterion='center',
random_state=self._randomstate)
for ii in range(num_init_sam):
xopt_ii = np.round(xL_iter + init_sam[ii] * (xU_iter - xL_iter)).reshape(num_des)
fopt_ii = self.objective_callback(xopt_ii)
if fopt_ii < UBD:
self.eflag_MINLPBB = True
UBD = fopt_ii
fopt = fopt_ii
xopt = xopt_ii
# This stuff is just for printing.
par_node = 0
# Active set fields: (Updated!)
# Aset = [[NodeNumber, lb, ub, LBD, UBD, nodeHist], [], ..]
active_set = []
nodeHist = NodeHist()
UBD_term = UBD
comm = problem.model.comm
if self.load_balance:
# Master/Worker config
n_proc = comm.size - 1
if n_proc < 2:
comm = None
n_proc = 1
else:
# Each proc has its own jobs
n_proc = comm.size
if n_proc < 2:
comm = None
# Initial node. This is the data structure we pass into the concurrent evaluator.
if self.aggressive_splitting:
# Initial number of nodes based on number of available procs
args = init_nodes(n_proc, xL_iter, xU_iter, par_node, LBD_prev, LBD,
UBD, fopt, xopt, nodeHist, ubd_count)
else:
# Start with 1 node.
args = [(xL_iter, xU_iter, par_node, LBD_prev, LBD, UBD, fopt,
xopt, node_num, nodeHist, ubd_count)]
# Main Loop
terminate = False
while not terminate:
# Branch and Bound evaluation of a set of nodes, starting with the initial one.
# When executed in serial, only a single node is evaluted.
cases = [(arg, None) for arg in args]
if self.load_balance:
results = concurrent_eval_lb(self.evaluate_node, cases,
comm, broadcast=True)
else:
results = concurrent_eval(self.evaluate_node, cases,
comm, allgather=True)
itercount += len(args)
if UBD < -1.0e-3:
ubd_count += len(args)
# Put all the new nodes into active set.
for result in results:
# Print the traceback if it fails
if not result[0]:
print(result[1])
new_UBD, new_fopt, new_xopt, new_nodes = result[0]
# Save stats for the best case.
if new_UBD < UBD:
UBD = new_UBD
fopt = new_fopt
xopt = new_xopt
# Look for substantial change in UBD to reset the counter
if abs(new_UBD - UBD_term) > 0.001:
ubd_count = 1
UBD_term = new_UBD
# TODO: Should we extend the active set with all the cases we
# ran, or just the best one. All for now.
active_set.extend(new_nodes)
node_num += len(new_nodes)
# Update active set: Removes all nodes worse than the best new node.
if len(active_set) >= 1:
active_set = update_active_set(active_set, UBD)
# Termination
if len(active_set) >= 1:
# Update LBD and select the current rectangle
args = []
# Grab the best nodes, as many as we have processors.
n_nodes = np.min((n_proc, len(active_set)))
for j in range(n_nodes):
# a. Set LBD as lowest in the active set
all_LBD = [item[3] for item in active_set]
LBD = min(all_LBD)
ind_LBD = all_LBD.index(LBD)
LBD_prev = LBD
# b. Select the lowest LBD node as the current node
par_node, xL_iter, xU_iter, _, _, nodeHist = active_set[ind_LBD]
self.iter_count += 1
args.append((xL_iter, xU_iter, par_node, LBD_prev, LBD, UBD, fopt,
xopt, node_num, nodeHist, ubd_count))
# c. Delete the selected node from the Active set of nodes
del active_set[ind_LBD]
# --------------------------------------------------------------
# Step 7: Check for convergence
# --------------------------------------------------------------
diff = np.abs(UBD - LBD)
if diff < atol:
terminate = True
if disp:
print("=" * 85)
print("Terminating! Absolute difference between the upper " +
"and lower bound is below the tolerence limit.")
else:
terminate = True
if disp:
print("=" * 85)
print("Terminating! No new node to explore.")
print("Max Node", node_num)
if itercount > maxiter or ubd_count > maxiter_ubd:
terminate = True
# Finalize by putting optimal value back into openMDAO
self.xopt = xopt
self.fopt = fopt
return False
def evaluate_node(self, xL_iter, xU_iter, par_node, LBD_prev, LBD, UBD, fopt, xopt, node_num,
nodeHist, ubd_count):
"""
Perform Branch and Bound step on a single node.
This function encapsulates the portion of the code that runs in parallel.
Parameters
----------
xL_iter : ndarray
Lower bound of design variables.
xU_iter : ndarray
Upper bound of design variables.
par_node : int
Index of parent node for this child node.
LBD_prev : float
Previous iteration value of LBD.
LBD : float
Current value of lower bound estimate.
UBD : float
Current value of upper bound esimate.
fopt : float
Current best objective value
xopt : ndarray
Current best design values.
node_num : int
Index of this current node
nodeHist : <NodeHist>
Data structure containing information about this node.
ubd_count : int
Counter for number of generations.
Returns
-------
float
New upper bound estimate.
float
New best objective value.
ndaray
New design variables.
list
List of parameters for new node.
"""
if OPTIMIZER == 'SNOPT':
options = {'Major optimality tolerance': 1.0e-5}
elif OPTIMIZER == 'SLSQP':
options = {'ACC': 1.0e-5}
elif OPTIMIZER == 'CONMIN':
options = {'DABFUN': 1.0e-5}
active_tol = self.options['active_tol']
local_search = self.options['local_search']
disp = self.options['disp']
trace_iter = self.options['trace_iter']
trace_iter_max = self.options['trace_iter_max']
obj_surrogate = self.obj_surrogate
num_des = len(self.xI_lb)
new_nodes = []
# Keep this to 0.49 to always round towards bottom-left
xloc_iter = np.round(xL_iter + 0.49 * (xU_iter - xL_iter))
floc_iter = self.objective_callback(xloc_iter)
# Genetic Algorithm
if local_search == 0:
# --------------------------------------------------------------
# Step 2: Obtain a local solution using a GA.
# --------------------------------------------------------------
ga = GeneticAlgorithm(self.obj_for_GA)
bits = np.ceil(np.log2(xU_iter - xL_iter + 1)).astype(int)
bits[bits <= 0] = 1
vub_vir = (2**bits - 1) + xL_iter
# More important nodes get a higher population size and number of generations.
if nodeHist.priority_flag == 1:
max_gen = 300
mfac = 6
else:
max_gen = 200
mfac = 4
L = np.sum(bits)
pop_size = mfac * L
t0 = time()
self.xU_iter = xU_iter
xloc_iter_new, floc_iter_new, nfit = \
ga.execute_ga(xL_iter, xL_iter, vub_vir, vub_vir, bits, pop_size, max_gen,
self._randomstate)
t_GA = time() - t0
if floc_iter_new < floc_iter:
floc_iter = floc_iter_new
xloc_iter = xloc_iter_new
# LHS Sampling or SNOPT
else:
# TODO Future research on sampling here
num_samples = np.round(np.max([10, np.min([50, num_des / nodeHist.priority_flag])]))
init_sam_node = lhs(num_des, samples=num_samples, criterion='center',
random_state=self._randomstate)
t_GA = 0.
for ii in range(int(num_samples)):
xloc_iter_new = np.round(xL_iter + init_sam_node[ii] * (xU_iter - xL_iter))
floc_iter_new = self.objective_callback(xloc_iter_new)
# SNOPT
if local_search == 2:
# TODO: did we lose a tol check here?
# active_tol: #Perform at non-flat starting point
if np.abs(floc_iter_new) > -np.inf:
# --------------------------------------------------------------
# Step 2: Obtain a local solution
# --------------------------------------------------------------
# Using a gradient-based method here.
# TODO: Make it more pluggable.
def _objcall(dv_dict):
"""
Compute objective for SNOPT.
"""
fail = 0
x = dv_dict['x']
# Objective
func_dict = {}
func_dict['obj'] = self.objective_callback(x)[0]
return func_dict, fail
xC_iter = xloc_iter_new
opt_x, opt_f, succ_flag, msg = snopt_opt(_objcall, xC_iter, xL_iter,
xU_iter, title='LocalSearch',
options=options)
xloc_iter_new = np.round(np.asarray(opt_x).flatten())
floc_iter_new = self.objective_callback(xloc_iter_new)
if floc_iter_new < floc_iter:
floc_iter = floc_iter_new
xloc_iter = xloc_iter_new
# Do some prechecks before commencing for partitioning.
ubdloc_best = nodeHist.ubdloc_best
if nodeHist.ubdloc_best > floc_iter + 1.0e-6:
ubd_track = np.concatenate((nodeHist.ubd_track, np.array([0])), axis=0)
ubdloc_best = floc_iter
else:
ubd_track = np.concatenate((nodeHist.ubd_track, np.array([1])), axis=0)
# diff_LBD = abs(LBD_prev - LBD_NegConEI)
if len(ubd_track) >= trace_iter_max or \
(len(ubd_track) >= trace_iter and np.sum(ubd_track[-trace_iter:]) == 0):
# TODO : Did we lose ths? -> #and UBD<=-1.0e-3:
child_info = np.array([[par_node, np.inf, floc_iter], [par_node, np.inf, floc_iter]])
# Fathomed due to no change in UBD_loc for 'trace_iter' generations
dis_flag = ['Y', 'Y']
else:
# --------------------------------------------------------------------------
# Step 3: Partition the current rectangle as per the new branching scheme.
# --------------------------------------------------------------------------
child_info = np.zeros([2, 3])
dis_flag = [' ', ' ']
# Choose
l_iter = (xU_iter - xL_iter).argmax()
if xloc_iter[l_iter] < xU_iter[l_iter]:
delta = 0.5 # 0<delta<1
else:
delta = -0.5 # -1<delta<0
for ii in range(2):
lb = xL_iter.copy()
ub = xU_iter.copy()
if ii == 0:
ub[l_iter] = np.floor(xloc_iter[l_iter] + delta)
elif ii == 1:
lb[l_iter] = np.ceil(xloc_iter[l_iter] + delta)
if np.linalg.norm(ub - lb) > active_tol: # Not a point
# --------------------------------------------------------------
# Step 4: Obtain an LBD of f in the newly created node
# --------------------------------------------------------------
S4_fail = False
x_comL, x_comU, Ain_hat, bin_hat = gen_coeff_bound(lb, ub, obj_surrogate)
sU, eflag_sU = self.maximize_S(x_comL, x_comU, Ain_hat, bin_hat)
if eflag_sU:
yL, eflag_yL = self.minimize_y(x_comL, x_comU, Ain_hat, bin_hat)
if eflag_yL:
NegEI = calc_conEI_norm([], obj_surrogate, SSqr=sU, y_hat=yL)
else:
S4_fail = True
else:
S4_fail = True
# Convex approximation failed!
if S4_fail:
LBD_NegConEI = LBD_prev
dis_flag[ii] = 'F'
else:
LBD_NegConEI = max(NegEI, LBD_prev)
# --------------------------------------------------------------
# Step 5: Store any new node inside the active set that has LBD
# lower than the UBD.
# --------------------------------------------------------------
priority_flag = 0
if LBD_NegConEI < np.inf and LBD_prev > -np.inf:
if np.abs((LBD_prev - LBD_NegConEI) / LBD_prev) < 0.005:
priority_flag = 1
nodeHist_new = NodeHist()
nodeHist_new.ubd_track = ubd_track
nodeHist_new.ubdloc_best = ubdloc_best
nodeHist_new.priority_flag = priority_flag
if LBD_NegConEI < UBD - 1.0e-6:
node_num += 1
new_node = [node_num, lb, ub, LBD_NegConEI, floc_iter, nodeHist_new]
new_nodes.append(new_node)
child_info[ii] = np.array([node_num, LBD_NegConEI, floc_iter])
else:
child_info[ii] = np.array([par_node, LBD_NegConEI, floc_iter])
# Flag for child created but not added to active set. (fathomed)
dis_flag[ii] = 'X'
else:
if ii == 1:
xloc_iter = ub
floc_iter = self.objective_callback(xloc_iter)
child_info[ii] = np.array([par_node, np.inf, floc_iter])
# Flag for No child created
dis_flag[ii] = 'x'
# Update the active set whenever better solution found
if floc_iter < UBD:
UBD = floc_iter
fopt = floc_iter
xopt = xloc_iter.reshape(num_des)
if disp:
if (self.iter_count - 1) % 25 == 0:
# Display output in a tabular format
print("=" * 95)
print("%19s%12s%14s%21s" % ("Global", "Parent", "Child1", "Child2"))
template = "%s%8s%10s%8s%9s%11s%10s%11s%11s%11s"
print(template % ("Iter", "LBD", "UBD", "Node", "Node1", "LBD1",
"Node2", "LBD2", "Flocal", "GA time"))
print("=" * 95)
template = "%3d%10.2f%10.2f%6d%8d%1s%13.2f%8d%1s%13.2f%9.2f%9.2f"
print(template % (self.iter_count, LBD, UBD, par_node, child_info[0, 0],
dis_flag[0], child_info[0, 1], child_info[1, 0],
dis_flag[1], child_info[1, 1], child_info[1, 2], t_GA))
return UBD, fopt, xopt, new_nodes
def objective_callback(self, xI):
"""
Evalute main problem objective at the requested point.
Objective is the expected improvement function with modifications to make it concave.
Parameters
----------
xI : ndarray
Value of design variables.
Returns
-------
float
Objective value
"""
obj_surrogate = self.obj_surrogate
# Normalized as per the convention in openmdao_Alpha:Kriging.
xval = (xI - obj_surrogate.X_mean) / obj_surrogate.X_std
NegEI = calc_conEI_norm(xval, obj_surrogate)
# print(xI, f)
return NegEI
def maximize_S(self, x_comL, x_comU, Ain_hat, bin_hat):
"""
Maximize the SigmaSqr Error.
This method finds an upper bound to the SigmaSqr Error, and scales up 'r' to provide a
smooth design space for gradient-based approach.
Parameters
----------
x_comL : ndarray
Full lower bounds vector
x_comU : ndarray
Full upper bounds vector.
Ain_hat : ndarray
Matrix Ain_hat for linear model of constraints.
bin_hat : ndarray
Vector bin_hat for linear model of constraints.
Returns
-------
float
Maximized upper bound for sigma squared error.
bool
Success flag True if successful.
"""
if OPTIMIZER == 'SNOPT':
options = {'Major optimality tolerance': 1.0e-5}
elif OPTIMIZER == 'SLSQP':
options = {'ACC': 1.0e-5}
elif OPTIMIZER == 'CONMIN':
options = {'DABFUN': 1.0e-5}
surrogate = self.obj_surrogate
R_inv = surrogate.R_inv
SigmaSqr = surrogate.SigmaSqr
X = surrogate.X
n, k = X.shape
one = np.ones([n, 1])
xhat_comL = x_comL.copy()
xhat_comU = x_comU.copy()
xhat_comL[k:] = 0.0
xhat_comU[k:] = 1.0
# Calculate the convexity factor alpha
rL = x_comL[k:]
rU = x_comU[k:]
dr_drhat = np.diag(rU[:, 0] - rL[:, 0])
T2_num = np.dot(np.dot(R_inv, one), np.dot(R_inv, one).T)
T2_den = np.dot(one.T, np.dot(R_inv, one))
d2S_dr2 = 2.0 * SigmaSqr * (R_inv - (T2_num / T2_den))
H_hat = np.dot(np.dot(dr_drhat, d2S_dr2), dr_drhat)
# Use Gershgorin's circle theorem to find a lower bound of the
# min eigen value of the hessian
eig_lb = np.zeros([n, 1])
for ii in range(n):
dia_ele = H_hat[ii, ii]
sum_rw = 0.0
sum_col = 0.0
for jj in range(n):
if ii != jj:
sum_rw += np.abs(H_hat[ii, jj])
sum_col += np.abs(H_hat[jj, ii])
eig_lb[ii] = dia_ele - np.min(np.array([sum_rw, sum_col]))
eig_min = np.min(eig_lb)
alpha = np.max(np.array([0.0, -0.5 * eig_min]))
# Maximize S
x0 = 0.5 * (xhat_comL + xhat_comU)
# Just storing stuff here to pull it out in the callback.
surrogate._alpha = alpha
self.x_comL = x_comL
self.x_comU = x_comU
self.xhat_comL = xhat_comL
self.xhat_comU = xhat_comU
self.Ain_hat = Ain_hat
self.bin_hat = bin_hat
opt_x, opt_f, succ_flag, msg = snopt_opt(self.calc_SSqr_convex, x0, xhat_comL,
xhat_comU, ncon=len(bin_hat),
title='Maximize_S',
options=options,
jac=Ain_hat,
sens=self.calc_SSqr_convex_grad)
Neg_sU = opt_f
# if not succ_flag:
# eflag_sU = False
# else:
# eflag_sU = True
eflag_sU = True
tol = self.options['con_tol']
for ii in range(2 * n):
if np.dot(Ain_hat[ii, :], opt_x) > (bin_hat[ii] + tol):
eflag_sU = False
break
sU = - Neg_sU
return sU, eflag_sU
def calc_SSqr_convex(self, dv_dict):
"""
Callback function for minimization of mean squared error.
Parameters
----------
dv_dict : dict
Dictionary of design variable values.
Returns
-------
func_dict : dict
Dictionary of all functional variables evaluated at design point.
fail : int
0 for successful function evaluation
1 for unsuccessful function evaluation
"""
fail = 0
x_com = dv_dict['x']
surrogate = self.obj_surrogate
R_inv = surrogate.R_inv
SigmaSqr = surrogate.SigmaSqr
alpha = surrogate._alpha
n, k = surrogate.X.shape
one = np.ones([n, 1])
rL = self.x_comL[k:]
rU = self.x_comU[k:]
rhat = x_com[k:].reshape(n, 1)
r = rL + rhat * (rU - rL)
rhat_L = self.xhat_comL[k:]
rhat_U = self.xhat_comU[k:]
term0 = np.dot(R_inv, r)
term1 = -SigmaSqr * (1.0 - r.T.dot(term0) +
((1.0 - one.T.dot(term0))**2 / (one.T.dot(np.dot(R_inv, one)))))
term2 = alpha * (rhat - rhat_L).T.dot(rhat - rhat_U)
S2 = term1 + term2
# Objectives
func_dict = {}
func_dict['obj'] = S2[0, 0]
# Constraints
Ain_hat = self.Ain_hat
bin_hat = self.bin_hat
func_dict['con'] = np.dot(Ain_hat, x_com) - bin_hat
# print('x', dv_dict)
# print('obj', func_dict['obj'])
return func_dict, fail
def calc_SSqr_convex_grad(self, dv_dict, func_dict):
"""
Callback function for gradient of mean squared error.
Parameters
----------
dv_dict : dict
Dictionary of design variable values.
func_dict : dict
Dictionary of all functional variables evaluated at design point.
Returns
-------
sens_dict : dict
Dictionary of dictionaries for gradient of each dv/func pair
fail : int
0 for successful function evaluation
1 for unsuccessful function evaluation
"""
fail = 0
x_com = dv_dict['x']
surrogate = self.obj_surrogate
X = surrogate.X
R_inv = surrogate.R_inv
SigmaSqr = surrogate.SigmaSqr
alpha = surrogate._alpha
n, k = X.shape
nn = len(x_com)
one = np.ones([n, 1])
rL = self.x_comL[k:]
rU = self.x_comU[k:]
rhat = x_com[k:].reshape(n, 1)
r = rL + rhat * (rU - rL)
rhat_L = self.xhat_comL[k:]
rhat_U = self.xhat_comU[k:]
dr_drhat = np.diag((rU - rL).flat)
term0 = np.dot(R_inv, r)
term1 = ((1.0 - one.T.dot(term0)) / (one.T.dot(np.dot(R_inv, one)))) * np.dot(R_inv, one)
term = 2.0 * SigmaSqr * (term0 + term1)
dterm1 = np.dot(dr_drhat, term)
dterm2 = alpha * (2.0 * rhat - rhat_L - rhat_U)
dobj_dr = (dterm1 + dterm2).T
# Objectives
sens_dict = OrderedDict()
sens_dict['obj'] = OrderedDict()
sens_dict['obj']['x'] = np.zeros((1, nn))
sens_dict['obj']['x'][:, k:] = dobj_dr
# Constraints
Ain_hat = self.Ain_hat
sens_dict['con'] = OrderedDict()
sens_dict['con']['x'] = Ain_hat
# print('obj deriv', sens_dict['obj']['x'] )
# print('con deriv', sens_dict['con']['x'])
return sens_dict, fail
def minimize_y(self, x_comL, x_comU, Ain_hat, bin_hat):
"""
Minimize the lower bound.
Parameters
----------
x_comL : ndarray
Full lower bounds vector
x_comU : ndarray
Full upper bounds vector.
Ain_hat : ndarray
Matrix Ain_hat for linear model of constraints.
bin_hat : ndarray
Vector bin_hat for linear model of constraints.
Returns
-------
float
Maximized upper bound for sigma squared error.
bool
Success flag True if successful.
"""
if OPTIMIZER == 'SNOPT':
options = {'Major optimality tolerance': 1.0e-8}
elif OPTIMIZER == 'SLSQP':
options = {'ACC': 1.0e-8}
elif OPTIMIZER == 'CONMIN':
options = {'DABFUN': 1.0e-8}
# 1- Formulates y_hat as LP (weaker bound)
# 2- Uses non-convex relaxation technique (stronger bound) [Future release]
app = 1
surrogate = self.obj_surrogate
X = surrogate.X
n, k = X.shape
xhat_comL = x_comL.copy()
xhat_comU = x_comU.copy()
xhat_comL[k:] = 0.0
xhat_comU[k:] = 1.0
if app == 1:
x0 = 0.5 * (xhat_comL + xhat_comU)
# Just storing stuff here to pull it out in the callback.
self.x_comL = x_comL
self.x_comU = x_comU
self.Ain_hat = Ain_hat
self.bin_hat = bin_hat
opt_x, opt_f, succ_flag, msg = snopt_opt(self.calc_y_hat_convex, x0, xhat_comL,
xhat_comU, ncon=len(bin_hat),
title='minimize_y',
options=options,
jac=Ain_hat,
sens=self.calc_y_hat_convex_grad)
yL = opt_f
# if not succ_flag:
# eflag_yL = False
# else:
# eflag_yL = True
eflag_yL = True
tol = self.options['con_tol']
for ii in range(2 * n):
if np.dot(Ain_hat[ii, :], opt_x) > (bin_hat[ii] + tol):
eflag_yL = False
break
return yL, eflag_yL
def calc_y_hat_convex(self, dv_dict):
"""
Callback function for objective during minimization of y_hat.
Parameters
----------
dv_dict : dict
Dictionary of design variable values.
Returns
-------
func_dict : dict
Dictionary of all functional variables evaluated at design point.
fail : int
0 for successful function evaluation
1 for unsuccessful function evaluation
"""
fail = 0
x_com = dv_dict['x']
surrogate = self.obj_surrogate
X = surrogate.X
c_r = surrogate.c_r
mu = surrogate.mu
n, k = X.shape
rL = self.x_comL[k:]
rU = self.x_comU[k:]
rhat = np.array([x_com[k:]]).reshape(n, 1)
r = rL + rhat * (rU - rL)
y_hat = mu + np.dot(r.T, c_r)
# Objective
func_dict = {}
func_dict['obj'] = y_hat[0, 0]
# Constraints
Ain_hat = self.Ain_hat
bin_hat = self.bin_hat
func_dict['con'] = np.dot(Ain_hat, x_com) - bin_hat
# print('x', dv_dict)
# print('obj', func_dict['obj'])
return func_dict, fail
def calc_y_hat_convex_grad(self, dv_dict, func_dict):
"""
Callback function for gradient during minimization of y_hat.
Parameters
----------
dv_dict : dict
Dictionary of design variable values.
func_dict : dict
Dictionary of all functional variables evaluated at design point.
Returns
-------
sens_dict : dict
Dictionary of dictionaries for gradient of each dv/func pair
fail : int
0 for successful function evaluation
1 for unsuccessful function evaluation
"""
fail = 0
x_com = dv_dict['x']
surrogate = self.obj_surrogate
X = surrogate.X
c_r = surrogate.c_r
n, k = X.shape
nn = len(x_com)
rL = self.x_comL[k:]
rU = self.x_comU[k:]
dobj_dr = c_r * (rU - rL)
# Objectives
sens_dict = OrderedDict()
sens_dict['obj'] = OrderedDict()
sens_dict['obj']['x'] = np.zeros((1, nn))
sens_dict['obj']['x'][:, k:] = dobj_dr.T
# Constraints
Ain_hat = self.Ain_hat
sens_dict['con'] = OrderedDict()
sens_dict['con']['x'] = Ain_hat
# print('obj deriv', sens_dict['obj']['x'] )
# print('con deriv', sens_dict['con']['x'])
return sens_dict, fail
def obj_for_GA(self, x, icase):
"""
Evalute main problem objective at the requested point.
Objective is the expected improvement function with modifications to make it concave.
Parameters
----------
x : ndarray
Value of design variables.
icase : int
Case number, used for identification when run in parallel.
Returns
-------
float
Objective value
bool
Success flag, True if successful
int
Case number, used for identification when run in parallel.
"""
surrogate = self.obj_surrogate
xU_iter = self.xU_iter
num_des = len(x)
P = 0.0
rp = 100.0
g = x / xU_iter - 1.0
idx = np.where(g > 0.0)
if len(idx) > 0:
P = np.einsum('i->', g[idx]**2)
xval = (x - surrogate.X_mean) / surrogate.X_std
NegEI = calc_conEI_norm(xval, surrogate)
f = NegEI + rp * P
return f, True, icase
def update_active_set(active_set, ubd):
"""
Update the active set.
Remove variables from the active set data structure if their current upper bound exceeds the
given value.
Parameters
----------
active_set : list of lists of floats
Active set data structure of form [[NodeNumber, lb, ub, LBD, UBD], [], ..]
ubd : float
Maximum for bounds test.
Returns
-------
list of list of floats
New active_set
"""
return [a for a in active_set if a[3] < ubd]
def gen_coeff_bound(xI_lb, xI_ub, surrogate):
"""
Generate upper and lower bounds for r.
This function generates the upper and lower bound of the artificial
variable r and the coefficients for the linearized under estimator
constraints. The version accepts design bound in the original design
space, converts it to normalized design space.
Parameters
----------
xI_lb : ndarray
Lower bound of the integer design variables.
xI_ub : ndarray
Upper bound of the integer design variables.
surrogate : <AMIEGOKrigingSurrogate>
Surrogate model of optimized objective with respect to integer design variables.
Returns
-------
ndarray
Full lower bounds vector
ndarray
Full upper bounds vector.
ndarray
Matrix Ain_hat for linear model of constraints.
ndarray
Vector bin_hat for linear model of constraints.
"""
mean = surrogate.X_mean
std = surrogate.X_std
# Normalized as per Openmdao kriging model
xL_hat = (xI_lb - mean) / std
xU_hat = (xI_ub - mean) / std
rL, rU = interval_analysis(xL_hat, xU_hat, surrogate)
# Combined design variables for supbproblem
num = len(xL_hat) + len(rL)
x_comL = np.append(xL_hat, rL).reshape(num, 1)
x_comU = np.append(xU_hat, rU).reshape(num, 1)
# Coefficients of the linearized constraints of the subproblem
Ain_hat, bin_hat = lin_underestimator(x_comL, x_comU, surrogate)
return x_comL, x_comU, Ain_hat, bin_hat
def interval_analysis(lb_x, ub_x, surrogate):
"""
Predict lower and upper bounds for r.
The module predicts the lower and upper bound of the artificial variable 'r' from the bounds
of the design variable x r is related to x by the following equation:
r_i = exp(-sum(theta_h*(x_h - x_h_i)^2))
Parameters
----------
lb_x : ndarray
Lower bound of the integer design variables.
ub_x : ndarray
Upper bound of the integer design variables.
surrogate : <AMIEGOKrigingSurrogate>
Surrogate model of optimized objective with respect to integer design variables.
Returns
-------
ndarray
Predicted lower bound for r
ndarray
Predicted upper bound for r
"""
p = surrogate.p
if p % 2 == 0:
X = surrogate.X
thetas = surrogate.thetas
n, k = X.shape
t3L = np.empty([n, k])
t3U = np.empty([n, k])
t1L = lb_x - X
t1U = ub_x - X
fac1 = t1L * t1L
fac2 = t1L * t1U
fac3 = t1U * t1U
for i in range(n):
for h in range(k):
fact = np.array([fac1[i, h], fac2[i, h], fac3[i, h]])
t2L = np.max(np.array([0, np.min(fact)]))
t2U = np.max(np.array([0, np.max(fact)]))
fact = -thetas[h] * np.array([t2L, t2U])
t3L[i, h] = np.min(fact)
t3U[i, h] = np.max(fact)
lb_r = np.exp(np.sum(t3L, axis=1))
ub_r = np.exp(np.sum(t3U, axis=1))
else:
print("\nWarning! Value of p should be 2. Cannot perform interval analysis")
print("\nReturing global bound of the r variable")
lb_r = np.zeros([n, k])
ub_r = np.zeros([n, k])
return lb_r, ub_r
def lin_underestimator(lb, ub, surrogate):
"""
Compute the coefficients of the linearized underestimator constraints.
Parameters
----------
lb : ndarray
Lower bound vector.
ub : ndarray
Upper bound vector
surrogate : <AMIEGOKrigingSurrogate>
Surrogate model of optimized objective with respect to integer design variables.
Returns
-------
ndarray
Matrix Ain_hat for linear model of constraints.
ndarray
Vector bin_hat for linear model of constraints.
"""
X = surrogate.X
thetas = surrogate.thetas
p = surrogate.p
n, k = X.shape
lb_x = lb[:k]
ub_x = ub[:k]
lb_r = lb[k:]
ub_r = ub[k:]
a1_hat = np.zeros([n, n])
a3_hat = np.zeros([n, n])
a2 = np.empty([n, k])
a4 = np.empty([n, k])
b2 = np.empty([n, k])
b4 = np.empty([n, k])
b1_hat = np.empty([n, ])
b3_hat = np.empty([n, ])
dist_r = ub_r - lb_r
dist_x = ub_x - lb_x
x_m = 0.5 * (ub_x + lb_x)
r_m = 0.5 * (lb_r + ub_r)
ub_fact = (ub_x - X.T)**p
lb_fact = (lb_x - X.T)**p
fact_p = (x_m - X.T)**p
fact_pm1 = (x_m - X.T)**(p - 1)
for i in range(n):
# T1: Linearize under-estimator of ln[r_i] = a1*r[i] + b1
if ub_r[i] <= lb_r[i]:
a1 = 0.0
else:
a1 = (np.log(ub_r[i]) - np.log(lb_r[i])) / dist_r[i]
b1 = np.log(ub_r[i]) - a1 * ub_r[i]
a1_hat[i, i] = a1 * dist_r[i]
b1_hat[i] = a1 * lb_r[i] + b1
# T3: Linearize under-estimator of -ln[r_i] = a3*r[i] + b3
a3 = -1.0 / r_m[i]
b3 = -np.log(r_m[i]) - a3 * r_m[i]
a3_hat[i, i] = a3 * dist_r[i]
b3_hat[i] = a3 * lb_r[i] + b3
for h in range(k):
# T2: Linearize under-estimator of thetas_h*(x_h - X_h_i)^2 = a4[i,h]*x_h[h] + b4[i,h]
a2[i, h] = p * thetas[h] * fact_pm1[h, i]
yy = thetas[h] * fact_p[h, i]
b2[i, h] = -a2[i, h] * x_m[h] + yy
# T4: Linearize under-estimator of -theta_h*(x_h - X_h_i)^2 = a4[i,h]*x_h[h] + b4[i,h]
yy1 = -thetas[h] * lb_fact[h, i]
if ub_x[h] <= lb_x[h]:
a4[i, h] = 0.0
else:
yy2 = -thetas[h] * ub_fact[h, i]
a4[i, h] = (yy2 - yy1) / dist_x[h]
b4[i, h] = -a4[i, h] * lb_x[h] + yy1
Ain1 = np.concatenate((a2, a4), axis=0)
Ain2 = np.concatenate((a1_hat, a3_hat), axis=0)
Ain_hat = np.concatenate((Ain1, Ain2), axis=1)
bin_hat = np.concatenate((-(b1_hat + np.sum(b2, axis=1)),
-(b3_hat + np.sum(b4, axis=1))), axis=0)
return Ain_hat, bin_hat
def calc_conEI_norm(xval, obj_surrogate, SSqr=None, y_hat=None):
"""
Evaluate the expected improvement in the normalized design space.
Parameters
----------
xval : ndarray
Value of the current integer design variables.
obj_surrogate : <AMIEGOKrigingSurrogate>
Surrogate model of optimized objective with respect to integer design variables.
SSqr : float
Pre-calculated value for sigma squared from successful maximize S.
y_hat : ndarray
Pre-calculated value for y_hat from successful maximize S.
Returns
-------
float
Negative of the expected improvement.
"""
y_min = obj_surrogate.y_best
if SSqr is None:
X = obj_surrogate.X
c_r = obj_surrogate.c_r
thetas = obj_surrogate.thetas
SigmaSqr = obj_surrogate.SigmaSqr
R_inv = obj_surrogate.R_inv
mu = obj_surrogate.mu
p = obj_surrogate.p
r = np.exp(-np.einsum("ij->i", thetas.T * (xval - X)**p))
y_hat = mu + | np.dot(r, c_r) | numpy.dot |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Built-in imports
from typing import Union
# 3rd party imports
import numpy as np
from scipy import interpolate
__author__ = "<NAME>"
__email__ = "<EMAIL>"
__copyright__ = "Copyright 2020-2021"
__license__ = "MIT"
__version__ = "2.3.7"
__status__ = "Prototype"
surface_materials = ['cluster', 'themis', 'cassini', 'aluminium', 'aquadag',
'gold', 'graphite', 'solar cells', '1eV', 'TiN',
'elgiloy']
j_zeros = {"cassini": 25e-6, "tin": 25e-6, "cluster": 25e-6,
"aluminium": 30e-6, "aquadag": 18e-6, "gold": 29e-6,
"graphite": 7.2e-6, "solar cells": 20e-6, "solar cell": 20e-6,
"elgiloy": 30e-6}
def photo_current(iluminated_area: float = None,
u: Union[float, np.ndarray] = None,
distance_sun: float = None,
flag: Union[str, float] = "cluster") -> Union[float,
np.ndarray]:
r"""Calculates the photo-current emitted by an arbitrary body.
Parameters
----------
iluminated_area : float
Cross section area [m^2].
u : float or numpy.ndarray
Potential [V].
distance_sun : float
Distance form the Sun [AU].
flag : str or float, Optional
Surface materials or surface photoemission in [A/m^2].
Default is "cluster".
Returns
-------
j_photo : float or numpy.ndarray
Photo-current emitted.
Notes
-----
Estimates are done for the solar minimum conditions.
"""
assert isinstance(flag, (str, float))
if not iluminated_area and not u and not distance_sun:
for surf in surface_materials:
j0 = photo_current(1, 0, 1, surf)
print(f"{surf}: Io= {j0 * 1e6:3.2f} uA/m2")
return
# Assert than u is an array
u = np.atleast_1d(u)
if isinstance(flag, (float, int)):
photoemisson = flag
# Initialize
j_photo = | np.ones(u.shape) | numpy.ones |
from particle_swarm_optimization.helper import random_position
import numpy as np
class Particle():
def __init__(self):
self.current_position = random_position()
self.best_position = self.current_position
self.best_value = self.fitness()
self.velocity = | np.array([0,0]) | numpy.array |
#! /usr/bin/env python
# Copyright 2021 <NAME>
#
# This file is part of WarpX.
#
# License: BSD-3-Clause-LBNL
import os
import sys
import yt
sys.path.insert(1, '../../../../warpx/Regression/Checksum/')
import checksumAPI
import numpy as np
import scipy.constants as scc
## This script performs various checks for the proton boron nuclear fusion module. The simulation
## that we check is made of 5 different tests, each with different proton, boron and alpha species.
##
## The first test is performed in the proton-boron center of mass frame. It could correspond to the
## physical case of a proton beam colliding with a boron beam. The kinetic energy of the colliding
## particles depends on the cell number in the z direction and varies in the few keV to few MeV
## range. All the particles within a cell have the exact same momentum, which allows detailed
## checks of the energy of produced alpha particles. The proton and boron species have the same
## density and number of particles in this test. The number of produced alphas is much smaller than
## the initial number of protons and borons.
##
## The second test is performed in the boron rest frame. It corresponds to the physical case of a
## low density proton beam colliding with a high-density proton+boron target. The energy of the
## proton beam is varied in the few keV to few MeV range, depending on the cell number in the z
## direction. As in the previous case, all the particles within a cell have the exact same
## momentum, which allows detailed checks of the energy of produced alpha particles. In this test,
## there are 100 immobile boron and 100 immobile proton macroparticles per cell, as well as 900
## beam proton macroparticles per cell. The density of the immobile particles is 6 orders of
## magnitude higher than the number of beam particles, which means that they have a much higher
## weight. This test is similar to the example given in section 3 of Higginson et al.,
## Journal of Computation Physics, 388 439–453 (2019), which was found to be sensitive to the way
## unsampled pairs are accounted for. As before, the number of produced alphas is much smaller than
## the initial number of protons and borons.
##
## The third test corresponds to a Maxwellian plasma with a 44 keV temperature. The alpha yield is
## directly compared to the analytical fits of <NAME> and <NAME>, Nuclear Fusion, 40, 865
## (2000) for a thermal plasma.
##
## The fourth test corresponds to a plasma with an extremely small boron density, so that all boron
## macroparticles should have disappeared by the end of the simulation, which we verify.
##
## The fifth test is exactly the same as the fourth test, except that the
## fusion_probability_threshold parameter is increased to an excessive value. Because of that, we
## severely underestimate the fusion yield and boron macroparticles remain at the end of the
## simulation, which we verify.
##
## In all simulations, we check particle number, charge, momentum and energy conservation and
## perform basic checks regarding the produced particles. When possible, we also compare the number
## of produced macroparticles, fusion yield and energy of the produced particles to theoretical
## values.
##
## Please be aware that the relative tolerances are often set empirically in this analysis script,
## so it would not be surprising that some tolerances need to be increased in the future.
default_tol = 1.e-12 # Default relative tolerance
## Some physical parameters
keV_to_Joule = scc.e*1e3
MeV_to_Joule = scc.e*1e6
barn_to_square_meter = 1.e-28
m_p = scc.m_p # Proton mass
m_b = 10.9298*m_p # Boron 11 mass
m_reduced = m_p*m_b/(m_p+m_b)
m_a = 3.97369*m_p # Alpha mass
m_be = 7.94748*m_p # Beryllium 8 mass
Z_boron = 5.
Z_proton = 1.
E_Gamow = (Z_boron*Z_proton*np.pi*scc.fine_structure)**2*2.*m_reduced*scc.c**2
E_Gamow_MeV = E_Gamow/MeV_to_Joule
E_Gamow_keV = E_Gamow/keV_to_Joule
E_fusion = 8.59009*MeV_to_Joule # Energy released during p + B -> alpha + Be
E_decay = 0.0918984*MeV_to_Joule # Energy released during Be -> 2*alpha
E_fusion_total = E_fusion + E_decay # Energy released during p + B -> 3*alpha
## Some numerical parameters for this test
size_x = 8
size_y = 8
size_z = 16
dV_total = size_x*size_y*size_z # Total simulation volume
# Volume of a slice corresponding to a single cell in the z direction. In tests 1 and 2, all the
# particles of a given species in the same slice have the exact same momentum
dV_slice = size_x*size_y
dt = 1./(scc.c*np.sqrt(3.))
# In test 1 and 2, the energy in cells number i (in z direction) is typically Energy_step * i**2
Energy_step = 22.*keV_to_Joule
def is_close(val1, val2, rtol=default_tol, atol=0.):
## Wrapper around numpy.isclose, used to override the default tolerances.
return np.isclose(val1, val2, rtol=rtol, atol=atol)
def add_existing_species_to_dict(yt_ad, data_dict, species_name, prefix, suffix):
data_dict[prefix+"_px_"+suffix] = yt_ad[species_name, "particle_momentum_x"].v
data_dict[prefix+"_py_"+suffix] = yt_ad[species_name, "particle_momentum_y"].v
data_dict[prefix+"_pz_"+suffix] = yt_ad[species_name, "particle_momentum_z"].v
data_dict[prefix+"_w_"+suffix] = yt_ad[species_name, "particle_weight"].v
data_dict[prefix+"_id_"+suffix] = yt_ad[species_name, "particle_id"].v
data_dict[prefix+"_cpu_"+suffix] = yt_ad[species_name, "particle_cpu"].v
data_dict[prefix+"_z_"+suffix] = yt_ad[species_name, "particle_position_z"].v
def add_empty_species_to_dict(data_dict, species_name, prefix, suffix):
data_dict[prefix+"_px_"+suffix] = np.empty(0)
data_dict[prefix+"_py_"+suffix] = np.empty(0)
data_dict[prefix+"_pz_"+suffix] = np.empty(0)
data_dict[prefix+"_w_"+suffix] = np.empty(0)
data_dict[prefix+"_id_"+suffix] = np.empty(0)
data_dict[prefix+"_cpu_"+suffix] = np.empty(0)
data_dict[prefix+"_z_"+suffix] = np.empty(0)
def add_species_to_dict(yt_ad, data_dict, species_name, prefix, suffix):
try:
## If species exist, we add its data to the dictionary
add_existing_species_to_dict(yt_ad, data_dict, species_name, prefix, suffix)
except yt.utilities.exceptions.YTFieldNotFound:
## If species does not exist, we avoid python crash and add empty arrays to the
## dictionnary. Currently, this happens for the boron species in test number 4, which
## entirely fuses into alphas.
add_empty_species_to_dict(data_dict, species_name, prefix, suffix)
def check_particle_number_conservation(data):
total_w_proton_start = np.sum(data["proton_w_start"])
total_w_proton_end = np.sum(data["proton_w_end"])
total_w_boron_start = np.sum(data["boron_w_start"])
total_w_boron_end = np.sum(data["boron_w_end"])
consumed_proton = total_w_proton_start - total_w_proton_end
consumed_boron = total_w_boron_start - total_w_boron_end
created_alpha = np.sum(data["alpha_w_end"])
assert(consumed_proton >= 0.)
assert(consumed_boron >= 0.)
assert(created_alpha >= 0.)
## Check that number of consumed proton and consumed boron are equal
assert_scale = max(total_w_proton_start, total_w_boron_start)
assert(is_close(consumed_proton, consumed_boron, rtol = 0., atol = default_tol*assert_scale))
## Check that number of consumed particles corresponds to number of produced alpha
## Factor 3 is here because each nuclear fusion reaction produces 3 alphas
assert(is_close(total_w_proton_start, total_w_proton_end + created_alpha/3.))
assert(is_close(total_w_boron_start, total_w_boron_end + created_alpha/3.))
def compute_energy_array(data, species_name, suffix, m):
## Relativistic computation of kinetic energy for a given species
psq_array = data[species_name+'_px_'+suffix]**2 + data[species_name+'_py_'+suffix]**2 + \
data[species_name+'_pz_'+suffix]**2
rest_energy = m*scc.c**2
return np.sqrt(psq_array*scc.c**2 + rest_energy**2) - rest_energy
def check_energy_conservation(data):
proton_energy_start = compute_energy_array(data, "proton", "start", m_p)
proton_energy_end = compute_energy_array(data, "proton", "end", m_p)
boron_energy_start = compute_energy_array(data, "boron", "start", m_b)
boron_energy_end = compute_energy_array(data, "boron", "end", m_b)
alpha_energy_end = compute_energy_array(data, "alpha", "end", m_a)
total_energy_start = np.sum(proton_energy_start*data["proton_w_start"]) + \
np.sum(boron_energy_start*data["boron_w_start"])
total_energy_end = np.sum(proton_energy_end*data["proton_w_end"]) + \
np.sum(boron_energy_end*data["boron_w_end"]) + \
np.sum(alpha_energy_end*data["alpha_w_end"])
## Factor 3 is here because each nuclear fusion reaction produces 3 alphas
n_fusion_reaction = | np.sum(data["alpha_w_end"]) | numpy.sum |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Apr 17 14:45:00 2017
@author: shenda
class order: ['A', 'N', 'O', '~']
"""
import numpy as np
from sklearn import ensemble
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from OptF import OptF
from copy import deepcopy
import xgboost as xgb
import ReadData
import random
from collections import Counter
class MyXGB(object):
"""
bottom basic classifier, a warpper for xgboost
the proba order is ['N', 'A', 'O', '~']
"""
def __init__(self, n_estimators=5000,
max_depth=10,
subsample=0.85,
colsample_bytree=0.85,
min_child_weight=4,
num_round = 500):
self.param = {'learning_rate':0.1, 'eta':0.1, 'silent':1,
'objective':'multi:softprob', 'num_class': 4}
self.bst = None
self.num_round = num_round
self.pred = None
my_seed = random.randint(0, 1000)
self.param['n_estimators'] = n_estimators
self.param['max_depth'] = max_depth
self.param['subsample'] = subsample
self.param['colsample_bytree'] = colsample_bytree
self.param['min_child_weight'] = min_child_weight
# self.param['random_state'] = my_seed
self.param['seed'] = my_seed
self.param['n_jobs'] = -1
print(self.param.items())
print(self.num_round)
def fit(self, train_data, train_label):
train_label = ReadData.Label2Index(train_label)
dtrain = xgb.DMatrix(train_data, label=train_label)
self.bst = xgb.train(self.param, dtrain, num_boost_round=self.num_round)
def predict_prob(self, test_data):
dtest = xgb.DMatrix(test_data)
self.pred = self.bst.predict(dtest)
return self.pred
def predict(self, test_data):
pred_prob = self.predict_prob(test_data)
pred_num = np.argmax(pred_prob, axis=1)
pred = ReadData.Index2Label(pred_num)
return pred
def get_importance(self):
return self.bst.get_score(importance_type='gain')
def plot_importance(self):
xgb.plot_importance(self.bst)
class MyLR(object):
"""
Top level classifier, a warpper for Logistic Regression
"""
def __init__(self):
self.clf = LogisticRegression()
def fit(self,
train_qrs_data, train_qrs_label):
train_data =np.array(train_qrs_data)
train_label = train_qrs_label
self.clf.fit(train_data, train_label)
def predict(self, test_qrs_data):
test_data = np.array(test_qrs_data)
if test_data.ndim == 1:
test_data = np.expand_dims(np.array(test_data), axis=0)
return list(self.clf.predict(test_data))
def predict_prob(self, test_qrs_data):
test_qrs_data = np.array(test_qrs_data)
if test_qrs_data.ndim == 1:
test_qrs_data = np.expand_dims(np.array(test_qrs_data), axis=0)
test_data = np.array(test_qrs_data)
return list(list(self.clf.predict_proba(test_data))[0])
else:
test_data = np.array(test_qrs_data)
return self.clf.predict_proba(test_data)
class MyKNN(object):
"""
bottom basic
support unequal length vector
"""
def __init__(self, n_neighbors=3):
self.n_neighbors = n_neighbors
self.train_data = None
self.train_label = None
self.labels = ['N', 'A', 'O', '~']
# self.thresh = [0.5, 0.3, 0.2, ]
def fit(self, train_data, train_label):
self.train_data = np.array(train_data)
self.train_label = np.array(train_label)
def dist(self, vec1, vec2):
res = 0.0
if len(vec1) <= len(vec2):
vec1 = np.r_[vec1, np.zeros(len(vec2)-len(vec1))]
else:
vec2 = np.r_[vec2, np.zeros(len(vec1)-len(vec2))]
dist_num = np.linalg.norm(vec1 - vec2)
return dist_num
def predict_prob(self, test_data):
test_data = np.array(test_data)
pred = []
for i in test_data:
tmp_dist_list = []
tmp_pred = []
for j in self.train_data:
tmp_dist_list.append(self.dist(i, j))
pred_n_neighbors = self.train_label[np.argsort(tmp_dist_list)[:self.n_neighbors]]
pred_counter = Counter(pred_n_neighbors)
# print(pred_counter)
for ii in self.labels:
tmp_pred.append(pred_counter[ii])
pred.append(tmp_pred)
return pred
def predict(self, test_data):
pred = self.predict_prob(test_data)
pred_label = []
for i in pred:
pred_label.append(self.labels[np.argsort(i)[-1]])
return pred_label
class MyGBDT(object):
"""
bottom basic a warpper for GradientBoostingClassifier
"""
def __init__(self):
self.clf = ensemble.GradientBoostingClassifier()
def fit(self,
train_data, train_label):
train_data =np.array(train_data)
self.clf.fit(train_data, train_label)
def predict(self, test_data):
test_data = np.array(test_data)
if test_data.ndim == 1:
test_data = np.expand_dims(np.array(test_data), axis=0)
return list(self.clf.predict(test_data))
def predict_prob(self, test_data):
test_data = np.array(test_data)
if test_data.ndim == 1:
test_data = np.expand_dims(np.array(test_data), axis=0)
test_data = np.array(test_data)
return list(list(self.clf.predict_proba(test_data))[0])
else:
test_data = np.array(test_data)
return self.clf.predict_proba(test_data)
class MyExtraTrees(object):
"""
bottom basic a warpper for ExtraTreesClassifier
"""
def __init__(self):
self.clf = ensemble.ExtraTreesClassifier(n_estimators=100)
def fit(self,
train_data, train_label):
train_data =np.array(train_data)
self.clf.fit(train_data, train_label)
def predict(self, test_data):
test_data = np.array(test_data)
if test_data.ndim == 1:
test_data = np.expand_dims(np.array(test_data), axis=0)
return list(self.clf.predict(test_data))
def predict_prob(self, test_data):
test_data = | np.array(test_data) | numpy.array |
"""
Compute lambdas for THC according to
PRX QUANTUM 2, 030305 (2021) Section II. D.
"""
import numpy as np
from chemftr.molecule import pyscf_to_cas
def compute_lambda(pyscf_mf, etaPp: np.ndarray, MPQ: np.ndarray, use_eri_thc_for_t=False):
"""
Compute lambda thc
Args:
pyscf_mf - PySCF mean field object
etaPp - leaf tensor for THC that is dim(nthc x norb). The nthc and norb is
inferred from this quantity.
MPQ - central tensor for THC factorization. dim(nthc x nthc)
Returns:
"""
nthc = etaPp.shape[0]
# grab tensors from pyscf_mf object
h1, eri_full, _, _, _ = pyscf_to_cas(pyscf_mf)
# computing Least-squares THC residual
CprP = np.einsum("Pp,Pr->prP", etaPp, etaPp) # this is einsum('mp,mq->pqm', etaPp, etaPp)
BprQ = np.tensordot(CprP, MPQ, axes=([2], [0]))
Iapprox = np.tensordot(CprP, np.transpose(BprQ), axes=([2], [0]))
deri = eri_full - Iapprox
res = 0.5 * np.sum((deri) ** 2)
# NOTE: remove in future once we resolve why it was being used in the first place.
# NOTE: see T construction for details.
eri_thc = np.einsum("Pp,Pr,Qq,Qs,PQ->prqs", etaPp, etaPp, etaPp, etaPp, MPQ, optimize=True)
# projecting into the THC basis requires each THC factor mu to be be normalized.
# we roll the normalization constant into the central tensor zeta
SPQ = etaPp.dot(etaPp.T) # (nthc x norb) x (norb x nthc) -> (nthc x nthc) metric
cP = np.diag(np.diag(SPQ)) # grab diagonal elements. equivalent to np.diag(np.diagonal(SPQ))
# no sqrts because we have two normalized THC vectors (index by mu and nu) on each side.
MPQ_normalized = cP.dot(MPQ).dot(cP) # get normalized zeta in Eq. 11 & 12
lambda_z = np.sum(np.abs(MPQ_normalized)) * 0.5 # Eq. 13
# NCR: originally Joonho's code add np.einsum('llij->ij', eri_thc)
# NCR: I don't know how much this matters.
if use_eri_thc_for_t:
# use eri_thc for second coulomb contraction. This was in the original code which is different than what the
# paper says.
T = h1 - 0.5 * np.einsum("illj->ij", eri_full) + np.einsum("llij->ij", eri_thc) # Eq. 3 + Eq. 18
else:
T = h1 - 0.5 * | np.einsum("illj->ij", eri_full) | numpy.einsum |
import click
@click.group()
def cli():
"""A group of potential sub methods that are available for use through
a command line interface
"""
@cli.command()
@click.option('--dir', type=str)
@click.option('--percentile', type=float, default=100.)
@click.option('--modifier', type=str, default="-fidelity")
@click.option('--load', is_flag=True, default=False)
def agreement_heatmap(dir, percentile, modifier, load):
import glob
import os
import tensorflow as tf
import tqdm
import numpy as np
import pandas as pd
import itertools
import scipy.stats as stats
from collections import defaultdict
from collections import defaultdict
import glob
import os
import re
import pickle as pkl
import tensorflow as tf
import tqdm
import seaborn as sns
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import json
import design_bench as db
from copy import deepcopy
plt.rcParams['text.usetex'] = True
matplotlib.rc('font', family='serif', serif='cm10')
matplotlib.rc('mathtext', fontset='cm')
color_palette = ['#EE7733',
'#0077BB',
'#33BBEE',
'#009988',
'#CC3311',
'#EE3377',
'#BBBBBB',
'#000000']
palette = sns.color_palette(color_palette)
sns.palplot(palette)
sns.set_palette(palette)
tasks = [
"gfp",
"superconductor"
]
baselines = [
"autofocused-cbas",
"cbas",
"bo-qei",
# "cma-es", didn't finish by the deadline
"gradient-ascent",
"gradient-ascent-min-ensemble",
"gradient-ascent-mean-ensemble",
"mins",
"reinforce"
]
metrics = [
"rank-correlation",
"max-shift",
"avg-shift"
]
baseline_to_logits = {
"autofocused-cbas": False,
"cbas": False,
"bo-qei": True,
"cma-es": True,
"gradient-ascent": True,
"gradient-ascent-min-ensemble": True,
"gradient-ascent-mean-ensemble": True,
"mins": False,
"reinforce": False
}
task_to_oracles = {
"gfp": [
"GP",
"RandomForest",
"FullyConnected",
"ResNet",
"Transformer"
],
"superconductor": [
# "GP",
"RandomForest",
"FullyConnected"
]
}
p = defaultdict(list)
task_pattern = re.compile(r'(\w+)-(\w+)-v(\d+)$')
if not load:
for baseline, task in tqdm.tqdm(
list(itertools.product(baselines, tasks))):
is_logits = baseline_to_logits[baseline]
files = glob.glob(os.path.join(dir, f"{baseline}{modifier}-"
f"{task}/*/*/*/solution.npy"))
for f in files:
solution_tensor = np.load(f)
params = os.path.join(os.path.dirname(
os.path.dirname(f)), "params.json")
with open(params, "r") as params_file:
params = json.load(params_file)
for oracle in task_to_oracles[task]:
matches = task_pattern.search(params["task"])
db_task = db.make(params["task"].replace(
matches.group(2), oracle), **params["task_kwargs"])
if is_logits and db_task.is_discrete:
db_task.map_to_logits()
elif db_task.is_discrete:
db_task.map_to_integers()
if params["normalize_xs"]:
db_task.map_normalize_x()
scores = db_task.predict(solution_tensor)
p[f"{baseline}-{task}-"
f"{oracle}"].append(np.percentile(scores, percentile))
print("aggregating performance")
p2 = dict()
if not load:
for task in tasks:
for oracle in task_to_oracles[task]:
p2[f"{task}-{oracle}"] = [
p[f"{baseline}-{task}-{oracle}"]
for baseline in baselines]
print("rendering heatmaps")
for metric, task in tqdm.tqdm(
list(itertools.product(metrics, tasks))):
task_oracles = task_to_oracles[task]
metric_data = np.zeros([len(task_oracles), len(task_oracles)])
if not load:
for i, oracle0 in enumerate(task_oracles):
for j, oracle1 in enumerate(task_oracles):
oracle0_data = deepcopy(p2[f"{task}-{oracle0}"])
oracle1_data = deepcopy(p2[f"{task}-{oracle1}"])
oracle0_data = [0.0 if len(value) == 0 else
np.mean(value) for value in oracle0_data]
oracle1_data = [0.0 if len(value) == 0 else
np.mean(value) for value in oracle1_data]
oracle0_data = np.array(oracle0_data)
oracle1_data = np.array(oracle1_data)
if metric == "rank-correlation":
rho = stats.spearmanr(oracle0_data, oracle1_data)[0]
metric_data[j][i] = rho
elif metric == "max-shift":
table0_index = oracle0_data.argsort().argsort()
table1_index = oracle1_data.argsort().argsort()
max_shift = np.abs(table0_index - table1_index).max()
metric_data[j][i] = max_shift
elif metric == "avg-shift":
table0_index = oracle0_data.argsort().argsort()
table1_index = oracle1_data.argsort().argsort()
avg_shift = np.abs(table0_index - table1_index).mean()
metric_data[j][i] = avg_shift
else:
metric_data = np.load(f'{task}{modifier}-{metric}-heatmap.npy')
# save a separate plot for every hyper parameter
plt.clf()
sns.heatmap(metric_data,
xticklabels=task_oracles,
yticklabels=task_oracles,
cbar_kws={'label': metric},
square=True, vmin=0,
vmax=1 if metric == "rank-correlation" else None)
plt.title(f"Oracle Agreement: {task}")
plt.xticks(rotation=90)
plt.yticks(rotation=0)
plt.savefig(f'{task}{modifier}-{metric}-heatmap.png', bbox_inches='tight')
np.save(f'{task}{modifier}-{metric}-heatmap.npy', metric_data)
@cli.command()
@click.option('--table0', type=str)
@click.option('--table1', type=str)
def rank_tables(table0, table1):
import glob
import os
import tensorflow as tf
import tqdm
import numpy as np
import pandas as pd
import scipy.stats as stats
tasks = [
"gfp",
"tf-bind-8",
"utr",
"hopper",
"superconductor",
"chembl",
"ant",
"dkitty"
]
metrics = [
"rank-correlation",
"max-shift",
"avg-shift"
]
table0_df = pd.read_csv(table0)
table1_df = pd.read_csv(table1)
final_data_numeric = [[None for t in tasks] for m in metrics]
for i, task in enumerate(tasks):
table0_rank = table0_df[task].to_numpy()
table1_rank = table1_df[task].to_numpy()
for j, metric in enumerate(metrics):
if metric == "rank-correlation":
rho = stats.spearmanr(table0_rank, table1_rank)[0]
final_data_numeric[j][i] = rho
elif metric == "max-shift":
table0_index = table0_rank.argsort().argsort()
table1_index = table1_rank.argsort().argsort()
final_data_numeric[j][i] = np.abs(table0_index - table1_index).max()
elif metric == "avg-shift":
table0_index = table0_rank.argsort().argsort()
table1_index = table1_rank.argsort().argsort()
final_data_numeric[j][i] = np.abs(table0_index - table1_index).mean()
final_df_numeric = pd.DataFrame(data=final_data_numeric, columns=tasks, index=metrics)
print(final_df_numeric.to_latex())
final_df_numeric.to_csv(f"{os.path.basename(table0)[:-4]}-to-"
f"{os.path.basename(table1)[:-4]}-rank-metrics.csv")
@cli.command()
@click.option('--dir', type=str)
@click.option('--samples', type=int, default=128)
@click.option('--percentile', type=int, default=100)
@click.option('--main-table', type=str, default="performance.csv")
@click.option('--load/--no-load', is_flag=True, default=False)
def make_diversity_table(dir, samples, percentile, main_table, load):
import glob
import os
import tqdm
import numpy as np
import itertools
import design_bench as db
import seaborn as sns
import matplotlib
import matplotlib.pyplot as plt
import json
import pandas as pd
plt.rcParams['text.usetex'] = True
matplotlib.rc('font', family='serif', serif='cm10')
matplotlib.rc('mathtext', fontset='cm')
color_palette = ['#EE7733',
'#0077BB',
'#33BBEE',
'#009988',
'#CC3311',
'#EE3377',
'#BBBBBB',
'#000000']
palette = sns.color_palette(color_palette)
sns.set_palette(palette)
tasks = [
"gfp",
"utr",
]
baselines = [
"autofocused-cbas",
"cbas",
"bo-qei",
#"cma-es",
"gradient-ascent",
"gradient-ascent-min-ensemble",
"gradient-ascent-mean-ensemble",
"mins",
"reinforce"
]
dist_options = [
"uniform",
"linear",
"quadratic",
"circular",
"exponential",
]
task_to_name = {
"gfp": "GFP",
"utr": "UTR",
}
if not load:
task_to_task = {
"gfp": db.make("GFP-Transformer-v0"),
"utr": db.make("UTR-ResNet-v0"),
}
baseline_to_logits = {
"autofocused-cbas": False,
"cbas": False,
"bo-qei": True,
"cma-es": True,
"gradient-ascent": True,
"gradient-ascent-min-ensemble": True,
"gradient-ascent-mean-ensemble": True,
"mins": False,
"reinforce": False
}
dist_to_performance = dict()
for dist in dist_options:
dist_to_performance[dist] = dict()
for task in tasks:
dist_to_performance[dist][task] = dict()
for baseline in baselines:
dist_to_performance[dist][task][baseline] = list()
for task, baseline in tqdm.tqdm(list(itertools.product(tasks, baselines))):
dirs = glob.glob(os.path.join(dir, f"{baseline}-{task}/*/*"))
for d in [d for d in dirs if os.path.isdir(d)]:
solution_files = glob.glob(os.path.join(d, '*/solution.npy'))[:samples]
for current_solution in solution_files:
params = os.path.join(os.path.dirname(
os.path.dirname(current_solution)), "params.json")
with open(params, "r") as p_file:
params = json.load(p_file)
dist = params["task_kwargs"]["dataset_kwargs"]["distribution"]
db_task = task_to_task[task]
is_logits = baseline_to_logits[baseline] and not task == "chembl"
if is_logits and db_task.is_discrete:
db_task.map_to_logits()
elif db_task.is_discrete:
db_task.map_to_integers()
if params["normalize_xs"]:
db_task.map_normalize_x()
scores = task_to_task[task].predict(np.load(current_solution))
dist_to_performance[dist][task][baseline]\
.append(np.percentile(scores, percentile))
for dist in dist_options:
for task, baseline in tqdm.tqdm(list(itertools.product(tasks, baselines))):
mean_perf = np.mean(dist_to_performance[dist][task][baseline])
dist_to_performance[dist][task][baseline] = mean_perf
diversity = np.zeros([len(tasks), len(dist_options)])
for task_idx, task in enumerate(tasks):
for dist_idx, dist in enumerate(dist_options):
diversity[task_idx, dist_idx] = np.std([
dist_to_performance[dist][task][b] for b in baselines])
np.save(f"dist-diversity-{percentile}.npy", diversity)
else:
diversity = | np.load(f"dist-diversity-{percentile}.npy") | numpy.load |
from __future__ import print_function, division
import os, sys, warnings, platform
from time import time
import numpy as np
if "PyPy" not in platform.python_implementation():
from scipy.io import loadmat, savemat
from Florence.Tensor import makezero, itemfreq, unique2d, in2d
from Florence.Utils import insensitive
from .vtk_writer import write_vtu
try:
import meshpy.triangle as triangle
has_meshpy = True
except ImportError:
has_meshpy = False
from .HigherOrderMeshing import *
from .NodeArrangement import *
from .GeometricPath import *
from warnings import warn
from copy import deepcopy
"""
Mesh class providing most of the pre-processing functionalities of the Core module
<NAME> - 13/06/2015
"""
class Mesh(object):
"""Mesh class provides the following functionalities:
1. Generating higher order meshes based on a linear mesh, for tris, tets, quads and hexes
2. Generating linear tri and tet meshes based on meshpy back-end
3. Generating linear tri meshes based on distmesh back-end
4. Finding bounary edges and faces for tris and tets, in case they are not provided by the mesh generator
5. Reading Salome meshes in binary (.dat/.txt/etc) format
6. Reading gmsh files .msh
7. Checking for node numbering order of elements and fixing it if desired
8. Writing meshes to unstructured vtk file format (.vtu) in xml and binary formats,
including high order elements
"""
def __init__(self, element_type=None):
super(Mesh, self).__init__()
# self.faces and self.edges ARE BOUNDARY FACES
# AND BOUNDARY EDGES, RESPECTIVELY
self.degree = None
self.ndim = None
self.edim = None
self.nelem = None
self.nnode = None
self.elements = None
self.points = None
self.corners = None
self.edges = None
self.faces = None
self.element_type = element_type
self.face_to_element = None
self.edge_to_element = None
self.boundary_edge_to_element = None
self.boundary_face_to_element = None
self.all_faces = None
self.all_edges = None
self.interior_faces = None
self.interior_edges = None
# TYPE OF BOUNDARY FACES/EDGES
self.boundary_element_type = None
# FOR GEOMETRICAL CURVES/SURFACES
self.edge_to_curve = None
self.face_to_surface = None
self.spatial_dimension = None
self.reader_type = None
self.reader_type_format = None
self.reader_type_version = None
self.writer_type = None
self.filename = None
# self.has_meshpy = has_meshpy
def SetElements(self,arr):
self.elements = arr
def SetPoints(self,arr):
self.points = arr
def SetEdges(self,arr):
self.edges = arr
def SetFaces(self,arr):
self.faces = arr
def GetElements(self):
return self.elements
def GetPoints(self):
return self.points
def GetEdges(self):
assert self.element_type is not None
if self.element_type == "tri":
self.GetEdgesTri()
elif self.element_type == "quad":
self.GetEdgesQuad()
elif self.element_type == "pent":
self.GetEdgesPent()
elif self.element_type == "tet":
self.GetEdgesTet()
elif self.element_type == "hex":
self.GetEdgesHex()
else:
raise ValueError('Type of element not understood')
return self.all_edges
def GetBoundaryEdges(self):
assert self.element_type is not None
if self.element_type == "tri":
self.GetBoundaryEdgesTri()
elif self.element_type == "quad":
self.GetBoundaryEdgesQuad()
elif self.element_type == "pent":
self.GetBoundaryEdgesPent()
elif self.element_type == "tet":
self.GetBoundaryEdgesTet()
elif self.element_type == "hex":
self.GetBoundaryEdgesHex()
else:
raise ValueError('Type of element not understood')
return self.edges
def GetInteriorEdges(self):
assert self.element_type is not None
if self.element_type == "tri":
self.GetInteriorEdgesTri()
elif self.element_type == "quad":
self.GetInteriorEdgesQuad()
elif self.element_type == "pent":
self.GetInteriorEdgesPent()
elif self.element_type == "tet":
self.GetInteriorEdgesTet()
elif self.element_type == "hex":
self.GetInteriorEdgesHex()
else:
raise ValueError('Type of element not understood')
return self.interior_edges
def GetFaces(self):
assert self.element_type is not None
if self.element_type == "tet":
self.GetFacesTet()
elif self.element_type == "hex":
self.GetFacesHex()
elif self.element_type=="tri" or self.element_type=="quad":
raise ValueError("2D mesh does not have faces")
else:
raise ValueError('Type of element not understood')
return self.all_faces
def GetBoundaryFaces(self):
assert self.element_type is not None
if self.element_type == "tet":
self.GetBoundaryFacesTet()
elif self.element_type == "hex":
self.GetBoundaryFacesHex()
elif self.element_type=="tri" or self.element_type=="quad":
raise ValueError("2D mesh does not have faces")
else:
raise ValueError('Type of element not understood')
return self.faces
def GetInteriorFaces(self):
assert self.element_type is not None
if self.element_type == "tet":
self.GetInteriorFacesTet()
elif self.element_type == "hex":
self.GetInteriorFacesHex()
elif self.element_type=="tri" or self.element_type=="quad":
raise ValueError("2D mesh does not have faces")
else:
raise ValueError('Type of element not understood')
return self.interior_faces
def GetElementsEdgeNumbering(self):
assert self.element_type is not None
if self.element_type == "tri":
return self.GetElementsEdgeNumberingTri()
elif self.element_type == "quad":
return self.GetElementsEdgeNumberingQuad()
else:
raise ValueError('Type of element not understood')
return self.edge_to_element
def GetElementsWithBoundaryEdges(self):
assert self.element_type is not None
if self.element_type == "tri":
return self.GetElementsWithBoundaryEdgesTri()
elif self.element_type == "quad":
return self.GetElementsWithBoundaryEdgesQuad()
else:
raise ValueError('Type of element not understood')
return self.boundary_edge_to_element
def GetElementsFaceNumbering(self):
assert self.element_type is not None
if self.element_type == "tet":
return self.GetElementsFaceNumberingTet()
elif self.element_type == "hex":
return self.GetElementsFaceNumberingHex()
elif self.element_type=="tri" or self.element_type=="quad":
raise ValueError("2D mesh does not have faces")
else:
raise ValueError('Type of element not understood')
return self.face_to_element
def GetElementsWithBoundaryFaces(self):
assert self.element_type is not None
if self.element_type == "tet":
return self.GetElementsWithBoundaryFacesTet()
elif self.element_type == "hex":
return self.GetElementsWithBoundaryFacesHex()
elif self.element_type=="tri" or self.element_type=="quad":
raise ValueError("2D mesh does not have faces")
else:
raise ValueError('Type of element not understood')
return self.boundary_face_to_element
@property
def Bounds(self):
"""Returns bounds of a mesh i.e. the minimum and maximum coordinate values
in every direction
"""
assert self.points is not None
if self.points.shape[1] == 3:
bounds = np.array([[np.min(self.points[:,0]),
np.min(self.points[:,1]),
np.min(self.points[:,2])],
[np.max(self.points[:,0]),
np.max(self.points[:,1]),
np.max(self.points[:,2])]])
makezero(bounds)
return bounds
elif self.points.shape[1] == 2:
bounds = np.array([[np.min(self.points[:,0]),
np.min(self.points[:,1])],
[np.max(self.points[:,0]),
np.max(self.points[:,1])]])
makezero(bounds)
return bounds
elif self.points.shape[1] == 1:
bounds = np.array([[np.min(self.points[:,0])],
[np.max(self.points[:,0])]])
makezero(bounds)
return bounds
else:
raise ValueError("Invalid dimension for mesh coordinates")
def GetEdgesTri(self):
"""Find all edges of a triangular mesh.
Sets all_edges property and returns it
returns:
arr: numpy ndarray of all edges"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.all_edges,np.ndarray):
if self.all_edges.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.all_edges.shape[1]==2 and p > 1:
pass
else:
return self.all_edges
node_arranger = NodeArrangementTri(p-1)[0]
# CHECK IF FACES ARE ALREADY AVAILABLE
if isinstance(self.all_edges,np.ndarray):
if self.all_edges.shape[0] > 1 and self.all_edges.shape[1] == p+1:
warn("Mesh edges seem to be already computed. I am going to recompute them")
# GET ALL EDGES FROM THE ELEMENT CONNECTIVITY
edges = np.zeros((3*self.elements.shape[0],p+1),dtype=np.uint64)
edges[:self.elements.shape[0],:] = self.elements[:,node_arranger[0,:]]
edges[self.elements.shape[0]:2*self.elements.shape[0],:] = self.elements[:,node_arranger[1,:]]
edges[2*self.elements.shape[0]:,:] = self.elements[:,node_arranger[2,:]]
# REMOVE DUPLICATES
edges, idx = unique2d(edges,consider_sort=True,order=False,return_index=True)
edge_to_element = np.zeros((edges.shape[0],2),np.int64)
edge_to_element[:,0] = idx % self.elements.shape[0]
edge_to_element[:,1] = idx // self.elements.shape[0]
self.edge_to_element = edge_to_element
# DO NOT SET all_edges IF THE CALLER FUNCTION IS GetBoundaryEdgesTet
import inspect
curframe = inspect.currentframe()
calframe = inspect.getouterframes(curframe, 2)[1][3]
if calframe != "GetBoundaryEdgesTet":
self.all_edges = edges
return edges
def GetBoundaryEdgesTri(self):
"""Find boundary edges (lines) of triangular mesh"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.edges,np.ndarray):
if self.edges.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.edges.shape[1] == 2 and p > 1:
pass
else:
return
node_arranger = NodeArrangementTri(p-1)[0]
# CONCATENATE ALL THE EDGES MADE FROM ELEMENTS
all_edges = np.concatenate((self.elements[:,node_arranger[0,:]],self.elements[:,node_arranger[1,:]],
self.elements[:,node_arranger[2,:]]),axis=0)
# GET UNIQUE ROWS
uniques, idx, inv = unique2d(all_edges,consider_sort=True,order=False,return_index=True,return_inverse=True)
# ROWS THAT APPEAR ONLY ONCE CORRESPOND TO BOUNDARY EDGES
freqs_inv = itemfreq(inv)
edges_ext_flags = freqs_inv[freqs_inv[:,1]==1,0]
# NOT ARRANGED
self.edges = uniques[edges_ext_flags,:]
# DETERMINE WHICH FACE OF THE ELEMENT THEY ARE
boundary_edge_to_element = np.zeros((edges_ext_flags.shape[0],2),dtype=np.int64)
# FURTHER RE-ARRANGEMENT / ARANGE THE NODES BASED ON THE ORDER THEY APPEAR
# IN ELEMENT CONNECTIVITY
# THIS STEP IS NOT NECESSARY INDEED - ITS JUST FOR RE-ARANGMENT OF EDGES
all_edges_in_edges = in2d(all_edges,self.edges,consider_sort=True)
all_edges_in_edges = np.where(all_edges_in_edges==True)[0]
boundary_edge_to_element[:,0] = all_edges_in_edges % self.elements.shape[0]
boundary_edge_to_element[:,1] = all_edges_in_edges // self.elements.shape[0]
# ARRANGE FOR ANY ORDER OF BASES/ELEMENTS AND ASSIGN DATA MEMBERS
self.edges = self.elements[boundary_edge_to_element[:,0][:,None],node_arranger[boundary_edge_to_element[:,1],:]]
self.edges = self.edges.astype(np.uint64)
self.boundary_edge_to_element = boundary_edge_to_element
return self.edges
def GetInteriorEdgesTri(self):
"""Computes interior edges of a triangular mesh
returns:
interior_edges ndarray of interior edges
edge_flags ndarray of edge flags: 0 for interior and 1 for boundary
"""
if not isinstance(self.all_edges,np.ndarray):
self.GetEdgesTri()
if not isinstance(self.edges,np.ndarray):
self.GetBoundaryEdgesTri()
sorted_all_edges = np.sort(self.all_edges,axis=1)
sorted_boundary_edges = np.sort(self.edges,axis=1)
x = []
for i in range(self.edges.shape[0]):
current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],
self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])
interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)
pos_interior_edges = np.where(interior_edges==0)[0]
if pos_interior_edges.shape[0] != 0:
x.append(pos_interior_edges)
edge_aranger = np.arange(self.all_edges.shape[0])
edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])
interior_edges = self.all_edges[edge_aranger,:]
# GET FLAGS FOR BOUNDRAY AND INTERIOR
edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)
edge_flags[edge_aranger] = 0
self.interior_edges = interior_edges
return interior_edges, edge_flags
def GetFacesTet(self):
"""Find all faces (surfaces) in the tetrahedral mesh (boundary & interior).
Sets all_faces property and returns it
returns:
arr: numpy ndarray of all faces
"""
# DETERMINE DEGREE
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.all_faces,np.ndarray):
if self.all_faces.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.all_faces.shape[1] == 3 and p > 1:
pass
else:
return self.all_faces
node_arranger = NodeArrangementTet(p-1)[0]
fsize = int((p+1.)*(p+2.)/2.)
# GET ALL FACES FROM THE ELEMENT CONNECTIVITY
faces = np.zeros((4*self.elements.shape[0],fsize),dtype=np.uint64)
faces[:self.elements.shape[0],:] = self.elements[:,node_arranger[0,:]]
faces[self.elements.shape[0]:2*self.elements.shape[0],:] = self.elements[:,node_arranger[1,:]]
faces[2*self.elements.shape[0]:3*self.elements.shape[0],:] = self.elements[:,node_arranger[2,:]]
faces[3*self.elements.shape[0]:,:] = self.elements[:,node_arranger[3,:]]
# REMOVE DUPLICATES
self.all_faces, idx = unique2d(faces,consider_sort=True,order=False,return_index=True)
face_to_element = np.zeros((self.all_faces.shape[0],2),np.int64)
face_to_element[:,0] = idx % self.elements.shape[0]
face_to_element[:,1] = idx // self.elements.shape[0]
self.face_to_element = face_to_element
return self.all_faces
def GetEdgesTet(self):
"""Find all edges (lines) of tetrahedral mesh (boundary & interior)"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.all_edges,np.ndarray):
if self.all_edges.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.all_edges.shape[1] == 2 and p > 1:
pass
else:
return self.all_edges
# FIRST GET BOUNDARY FACES
if isinstance(self.all_faces,np.ndarray):
if self.all_faces.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.all_faces.shape[1] == 3 and p > 1:
self.GetFacesTet()
else:
self.GetFacesTet()
# BUILD A 2D MESH
tmesh = Mesh()
# tmesh = deepcopy(self)
tmesh.element_type = "tri"
tmesh.elements = self.all_faces
tmesh.nelem = tmesh.elements.shape[0]
del tmesh.faces
del tmesh.points
# COMPUTE ALL EDGES
self.all_edges = tmesh.GetEdgesTri()
return self.all_edges
def GetBoundaryFacesTet(self):
"""Find boundary faces (surfaces) of a tetrahedral mesh"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.faces,np.ndarray):
if self.faces.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.faces.shape[1] == 3 and p > 1:
pass
else:
return
node_arranger = NodeArrangementTet(p-1)[0]
# CONCATENATE ALL THE FACES MADE FROM ELEMENTS
all_faces = np.concatenate((self.elements[:,:3],self.elements[:,[0,1,3]],
self.elements[:,[0,2,3]],self.elements[:,[1,2,3]]),axis=0)
# GET UNIQUE ROWS
uniques, idx, inv = unique2d(all_faces,consider_sort=True,order=False,return_index=True,return_inverse=True)
# ROWS THAT APPEAR ONLY ONCE CORRESPOND TO BOUNDARY FACES
freqs_inv = itemfreq(inv)
faces_ext_flags = freqs_inv[freqs_inv[:,1]==1,0]
# NOT ARRANGED
self.faces = uniques[faces_ext_flags,:]
# DETERMINE WHICH FACE OF THE ELEMENT THEY ARE
boundary_face_to_element = np.zeros((faces_ext_flags.shape[0],2),dtype=np.int64)
# THE FOLLOWING WILL COMPUTE FACES BASED ON SORTING AND NOT TAKING INTO ACCOUNT
# THE ELEMENT CONNECTIVITY
# boundary_face_to_element[:,0] = np.remainder(idx[faces_ext_flags],self.elements.shape[0])
# boundary_face_to_element[:,1] = np.floor_divide(idx[faces_ext_flags],self.elements.shape[0])
# OR EQUIVALENTLY
# boundary_face_to_element[:,0] = idx[faces_ext_flags] % self.elements.shape[0]
# boundary_face_to_element[:,1] = idx[faces_ext_flags] // self.elements.shape[0]
# FURTHER RE-ARRANGEMENT / ARANGE THE NODES BASED ON THE ORDER THEY APPEAR
# IN ELEMENT CONNECTIVITY
# THIS STEP IS NOT NECESSARY INDEED - ITS JUST FOR RE-ARANGMENT OF FACES
all_faces_in_faces = in2d(all_faces,self.faces,consider_sort=True)
all_faces_in_faces = np.where(all_faces_in_faces==True)[0]
# boundary_face_to_element = np.zeros((all_faces_in_faces.shape[0],2),dtype=np.int64)
boundary_face_to_element[:,0] = all_faces_in_faces % self.elements.shape[0]
boundary_face_to_element[:,1] = all_faces_in_faces // self.elements.shape[0]
# ARRANGE FOR ANY ORDER OF BASES/ELEMENTS AND ASSIGN DATA MEMBERS
self.faces = self.elements[boundary_face_to_element[:,0][:,None],node_arranger[boundary_face_to_element[:,1],:]]
self.faces = self.faces.astype(np.uint64)
self.boundary_face_to_element = boundary_face_to_element
def GetBoundaryEdgesTet(self):
"""Find boundary edges (lines) of tetrahedral mesh.
Note that for tetrahedrals this function is more robust than Salome's default edge generator
"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.edges,np.ndarray):
if self.edges.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.edges.shape[1] == 2 and p > 1:
pass
else:
return
# FIRST GET BOUNDARY FACES
if not isinstance(self.faces,np.ndarray):
self.GetBoundaryFacesTet()
# BUILD A 2D MESH
tmesh = Mesh()
tmesh.element_type = "tri"
tmesh.elements = self.faces
tmesh.nelem = tmesh.elements.shape[0]
del tmesh.faces
del tmesh.points
# ALL THE EDGES CORRESPONDING TO THESE BOUNDARY FACES ARE BOUNDARY EDGES
self.edges = tmesh.GetEdgesTri()
def GetInteriorFacesTet(self):
"""Computes interior faces of a tetrahedral mesh
returns:
interior_faces ndarray of interior faces
face_flags 1D array of face flags: 0 for interior and 1 for boundary
"""
if not isinstance(self.all_faces,np.ndarray):
self.GetFacesTet()
if not isinstance(self.faces,np.ndarray):
self.GetBoundaryFacesTet()
face_flags = in2d(self.all_faces.astype(self.faces.dtype),self.faces,consider_sort=True)
face_flags[face_flags==True] = 1
face_flags[face_flags==False] = 0
interior_faces = self.all_faces[face_flags==False,:]
return interior_faces, face_flags
def GetInteriorEdgesTet(self):
"""Computes interior faces of a tetrahedral mesh
returns:
interior_edges ndarray of interior edges
edge_flags 1D array of edge flags: 0 for interior and 1 for boundary
"""
if not isinstance(self.all_edges,np.ndarray):
self.GetEdgesTet()
if not isinstance(self.edges,np.ndarray):
self.GetBoundaryEdgesTet()
edge_flags = in2d(self.all_edges.astype(self.edges.dtype),self.edges,consider_sort=True)
edge_flags[edge_flags==True] = 1
edge_flags[edge_flags==False] = 0
interior_edges = self.all_edges[edge_flags==False,:]
self.interior_edges = interior_edges
return interior_edges, edge_flags
def GetEdgesQuad(self):
"""Find the all edges of a quadrilateral mesh.
Sets all_edges property and returns it
returns:
arr: numpy ndarray of all edges"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.all_edges,np.ndarray):
if self.all_edges.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.all_edges.shape[1]==2 and p > 1:
pass
else:
return self.all_edges
node_arranger = NodeArrangementQuad(p-1)[0]
# GET ALL EDGES FROM THE ELEMENT CONNECTIVITY
edges = np.concatenate((self.elements[:,node_arranger[0,:]],self.elements[:,node_arranger[1,:]],
self.elements[:,node_arranger[2,:]],self.elements[:,node_arranger[3,:]]),axis=0).astype(np.uint64)
# REMOVE DUPLICATES
edges, idx = unique2d(edges,consider_sort=True,order=False,return_index=True)
edge_to_element = np.zeros((edges.shape[0],2),np.int64)
edge_to_element[:,0] = idx % self.elements.shape[0]
edge_to_element[:,1] = idx // self.elements.shape[0]
self.edge_to_element = edge_to_element
# DO NOT SET all_edges IF THE CALLER FUNCTION IS GetBoundaryEdgesHex
import inspect
curframe = inspect.currentframe()
calframe = inspect.getouterframes(curframe, 2)[1][3]
if calframe != "GetBoundaryEdgesHex":
self.all_edges = edges
return edges
def GetBoundaryEdgesQuad(self):
"""Find boundary edges (lines) of a quadrilateral mesh"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.edges,np.ndarray):
if self.edges.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.edges.shape[1] == 2 and p > 1:
pass
else:
return
node_arranger = NodeArrangementQuad(p-1)[0]
# GET ALL EDGES FROM THE ELEMENT CONNECTIVITY
all_edges = np.concatenate((self.elements[:,node_arranger[0,:]],self.elements[:,node_arranger[1,:]],
self.elements[:,node_arranger[2,:]],self.elements[:,node_arranger[3,:]]),axis=0).astype(np.uint64)
# GET UNIQUE ROWS
uniques, idx, inv = unique2d(all_edges,consider_sort=True,order=False,return_index=True,return_inverse=True)
# ROWS THAT APPEAR ONLY ONCE CORRESPOND TO BOUNDARY EDGES
freqs_inv = itemfreq(inv)
edges_ext_flags = freqs_inv[freqs_inv[:,1]==1,0]
# NOT ARRANGED
self.edges = uniques[edges_ext_flags,:]
# DETERMINE WHICH FACE OF THE ELEMENT THEY ARE
boundary_edge_to_element = np.zeros((edges_ext_flags.shape[0],2),dtype=np.int64)
# FURTHER RE-ARRANGEMENT / ARANGE THE NODES BASED ON THE ORDER THEY APPEAR
# IN ELEMENT CONNECTIVITY
# THIS STEP IS NOT NECESSARY INDEED - ITS JUST FOR RE-ARANGMENT OF EDGES
all_edges_in_edges = in2d(all_edges,self.edges,consider_sort=True)
all_edges_in_edges = np.where(all_edges_in_edges==True)[0]
boundary_edge_to_element[:,0] = all_edges_in_edges % self.elements.shape[0]
boundary_edge_to_element[:,1] = all_edges_in_edges // self.elements.shape[0]
# ARRANGE FOR ANY ORDER OF BASES/ELEMENTS AND ASSIGN DATA MEMBERS
self.edges = self.elements[boundary_edge_to_element[:,0][:,None],node_arranger[boundary_edge_to_element[:,1],:]]
self.edges = self.edges.astype(np.uint64)
self.boundary_edge_to_element = boundary_edge_to_element
return self.edges
def GetInteriorEdgesQuad(self):
"""Computes interior edges of a quadrilateral mesh
returns:
interior_faces ndarray of interior edges
edge_flags ndarray of edge flags: 0 for interior and 1 for boundary
"""
if not isinstance(self.all_edges,np.ndarray):
self.GetEdgesQuad()
if not isinstance(self.edges,np.ndarray):
self.GetBoundaryEdgesQuad()
sorted_all_edges = np.sort(self.all_edges,axis=1)
sorted_boundary_edges = np.sort(self.edges,axis=1)
x = []
for i in range(self.edges.shape[0]):
current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],
self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])
interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)
pos_interior_edges = np.where(interior_edges==0)[0]
if pos_interior_edges.shape[0] != 0:
x.append(pos_interior_edges)
edge_aranger = np.arange(self.all_edges.shape[0])
edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])
interior_edges = self.all_edges[edge_aranger,:]
# GET FLAGS FOR BOUNDRAY AND INTERIOR
edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)
edge_flags[edge_aranger] = 0
self.interior_edges = interior_edges
return interior_edges, edge_flags
def GetFacesHex(self):
"""Find all faces (surfaces) in the hexahedral mesh (boundary & interior).
Sets all_faces property and returns it
returns:
arr: numpy ndarray of all faces
"""
# DETERMINE DEGREE
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.all_faces,np.ndarray):
if self.all_faces.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.all_faces.shape[1] == 4 and p > 1:
pass
else:
return self.all_faces
node_arranger = NodeArrangementHex(p-1)[0]
fsize = int((p+1)**3)
# GET ALL FACES FROM THE ELEMENT CONNECTIVITY
faces = np.concatenate((np.concatenate((
np.concatenate((np.concatenate((np.concatenate((self.elements[:,node_arranger[0,:]],
self.elements[:,node_arranger[1,:]]),axis=0),self.elements[:,node_arranger[2,:]]),axis=0),
self.elements[:,node_arranger[3,:]]),axis=0),self.elements[:,node_arranger[4,:]]),axis=0),
self.elements[:,node_arranger[5,:]]),axis=0).astype(np.int64)
# REMOVE DUPLICATES
self.all_faces, idx = unique2d(faces,consider_sort=True,order=False,return_index=True)
face_to_element = np.zeros((self.all_faces.shape[0],2),np.int64)
face_to_element[:,0] = idx % self.elements.shape[0]
face_to_element[:,1] = idx // self.elements.shape[0]
self.face_to_element = face_to_element
return self.all_faces
def GetEdgesHex(self):
"""Find all edges (lines) of tetrahedral mesh (boundary & interior)"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.all_edges,np.ndarray):
if self.all_edges.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.all_edges.shape[1] == 2 and p > 1:
pass
else:
return self.all_edges
# FIRST GET BOUNDARY FACES
if not isinstance(self.all_faces,np.ndarray):
self.GetFacesHex()
# BUILD A 2D MESH
tmesh = Mesh()
# tmesh = deepcopy(self)
tmesh.element_type = "quad"
tmesh.elements = self.all_faces
tmesh.nelem = tmesh.elements.shape[0]
del tmesh.faces
del tmesh.points
# COMPUTE ALL EDGES
self.all_edges = tmesh.GetEdgesQuad()
return self.all_edges
def GetBoundaryFacesHex(self):
"""Find boundary faces (surfaces) of a hexahedral mesh"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.faces,np.ndarray):
if self.faces.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.faces.shape[1] == 4 and p > 1:
pass
else:
return
node_arranger = NodeArrangementHex(p-1)[0]
# CONCATENATE ALL THE FACES MADE FROM ELEMENTS
all_faces = np.concatenate((np.concatenate((
np.concatenate((np.concatenate((np.concatenate((self.elements[:,node_arranger[0,:]],
self.elements[:,node_arranger[1,:]]),axis=0),self.elements[:,node_arranger[2,:]]),axis=0),
self.elements[:,node_arranger[3,:]]),axis=0),self.elements[:,node_arranger[4,:]]),axis=0),
self.elements[:,node_arranger[5,:]]),axis=0).astype(np.int64)
# GET UNIQUE ROWS
uniques, idx, inv = unique2d(all_faces,consider_sort=True,order=False,return_index=True,return_inverse=True)
# ROWS THAT APPEAR ONLY ONCE CORRESPOND TO BOUNDARY FACES
freqs_inv = itemfreq(inv)
faces_ext_flags = freqs_inv[freqs_inv[:,1]==1,0]
# NOT ARRANGED
self.faces = uniques[faces_ext_flags,:]
# DETERMINE WHICH FACE OF THE ELEMENT THEY ARE
boundary_face_to_element = np.zeros((faces_ext_flags.shape[0],2),dtype=np.int64)
# FURTHER RE-ARRANGEMENT / ARANGE THE NODES BASED ON THE ORDER THEY APPEAR
# IN ELEMENT CONNECTIVITY
# THIS STEP IS NOT NECESSARY INDEED - ITS JUST FOR RE-ARANGMENT OF FACES
all_faces_in_faces = in2d(all_faces,self.faces,consider_sort=True)
all_faces_in_faces = np.where(all_faces_in_faces==True)[0]
# boundary_face_to_element = np.zeros((all_faces_in_faces.shape[0],2),dtype=np.int64)
boundary_face_to_element[:,0] = all_faces_in_faces % self.elements.shape[0]
boundary_face_to_element[:,1] = all_faces_in_faces // self.elements.shape[0]
# ARRANGE FOR ANY ORDER OF BASES/ELEMENTS AND ASSIGN DATA MEMBERS
self.faces = self.elements[boundary_face_to_element[:,0][:,None],node_arranger[boundary_face_to_element[:,1],:]]
self.faces = self.faces.astype(np.uint64)
self.boundary_face_to_element = boundary_face_to_element
def GetBoundaryEdgesHex(self):
"""Find boundary edges (lines) of hexahedral mesh.
"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.edges,np.ndarray):
if self.edges.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.edges.shape[1] == 2 and p > 1:
pass
else:
return
# FIRST GET BOUNDARY FACES
if not isinstance(self.faces,np.ndarray):
self.GetBoundaryFacesHex()
# BUILD A 2D MESH
tmesh = Mesh()
tmesh.element_type = "quad"
tmesh.elements = self.faces
tmesh.nelem = tmesh.elements.shape[0]
del tmesh.faces
del tmesh.points
# ALL THE EDGES CORRESPONDING TO THESE BOUNDARY FACES ARE BOUNDARY EDGES
self.edges = tmesh.GetEdgesQuad()
def GetInteriorFacesHex(self):
"""Computes interior faces of a hexahedral mesh
returns:
interior_faces ndarray of interior faces
face_flags 1D array of face flags: 0 for interior and 1 for boundary
"""
if not isinstance(self.all_faces,np.ndarray):
self.GetFacesHex()
if not isinstance(self.faces,np.ndarray):
self.GetBoundaryFacesHex()
face_flags = in2d(self.all_faces.astype(self.faces.dtype),self.faces,consider_sort=True)
face_flags[face_flags==True] = 1
face_flags[face_flags==False] = 0
interior_faces = self.all_faces[face_flags==False,:]
return interior_faces, face_flags
def GetInteriorEdgesHex(self):
"""Computes interior faces of a hexahedral mesh
returns:
interior_edges ndarray of interior edges
edge_flags 1D array of edge flags: 0 for interior and 1 for boundary
"""
if not isinstance(self.all_edges,np.ndarray):
self.GetEdgesHex()
if not isinstance(self.edges,np.ndarray):
self.GetBoundaryEdgesHex()
edge_flags = in2d(self.all_edges.astype(self.edges.dtype),self.edges,consider_sort=True)
edge_flags[edge_flags==True] = 1
edge_flags[edge_flags==False] = 0
interior_edges = self.all_edges[edge_flags==False,:]
self.interior_edges = interior_edges
return interior_edges, edge_flags
def GetEdgesPent(self):
"""Find the all edges of a pentagonal mesh.
Sets all_edges property and returns it
returns:
arr: numpy ndarray of all edges"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.all_edges,np.ndarray):
if self.all_edges.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.all_edges.shape[1]==2 and p > 1:
pass
else:
return self.all_edges
node_arranger = np.array([
[0,1],
[1,2],
[2,3],
[3,4],
[4,0],
])
# GET ALL EDGES FROM THE ELEMENT CONNECTIVITY
edges = np.concatenate((self.elements[:,node_arranger[0,:]],self.elements[:,node_arranger[1,:]],
self.elements[:,node_arranger[2,:]],self.elements[:,node_arranger[3,:]],
self.elements[:,node_arranger[4,:]]),axis=0).astype(np.uint64)
# REMOVE DUPLICATES
edges, idx = unique2d(edges,consider_sort=True,order=False,return_index=True)
edge_to_element = np.zeros((edges.shape[0],2),np.int64)
edge_to_element[:,0] = idx % self.elements.shape[0]
edge_to_element[:,1] = idx // self.elements.shape[0]
self.edge_to_element = edge_to_element
self.all_edges = edges
return edges
def GetBoundaryEdgesPent(self):
"""Find boundary edges (lines) of a pentagonal mesh"""
p = self.InferPolynomialDegree()
# DO NOT COMPUTE IF ALREADY COMPUTED
if isinstance(self.edges,np.ndarray):
if self.edges.shape[0] > 1:
# IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION
if self.edges.shape[1] == 2 and p > 1:
pass
else:
return
node_arranger = np.array([
[0,1],
[1,2],
[2,3],
[3,4],
[4,0],
])
# GET ALL EDGES FROM THE ELEMENT CONNECTIVITY
all_edges = np.concatenate((self.elements[:,node_arranger[0,:]],self.elements[:,node_arranger[1,:]],
self.elements[:,node_arranger[2,:]],self.elements[:,node_arranger[3,:]],
self.elements[:,node_arranger[4,:]]),axis=0).astype(np.uint64)
# GET UNIQUE ROWS
uniques, idx, inv = unique2d(all_edges,consider_sort=True,order=False,return_index=True,return_inverse=True)
# ROWS THAT APPEAR ONLY ONCE CORRESPOND TO BOUNDARY EDGES
freqs_inv = itemfreq(inv)
edges_ext_flags = freqs_inv[freqs_inv[:,1]==1,0]
# NOT ARRANGED
self.edges = uniques[edges_ext_flags,:]
# DETERMINE WHICH FACE OF THE ELEMENT THEY ARE
boundary_edge_to_element = np.zeros((edges_ext_flags.shape[0],2),dtype=np.int64)
# FURTHER RE-ARRANGEMENT / ARANGE THE NODES BASED ON THE ORDER THEY APPEAR
# IN ELEMENT CONNECTIVITY
# THIS STEP IS NOT NECESSARY INDEED - ITS JUST FOR RE-ARANGMENT OF EDGES
all_edges_in_edges = in2d(all_edges,self.edges,consider_sort=True)
all_edges_in_edges = np.where(all_edges_in_edges==True)[0]
boundary_edge_to_element[:,0] = all_edges_in_edges % self.elements.shape[0]
boundary_edge_to_element[:,1] = all_edges_in_edges // self.elements.shape[0]
# ARRANGE FOR ANY ORDER OF BASES/ELEMENTS AND ASSIGN DATA MEMBERS
self.edges = self.elements[boundary_edge_to_element[:,0][:,None],node_arranger[boundary_edge_to_element[:,1],:]]
self.edges = self.edges.astype(np.uint64)
self.boundary_edge_to_element = boundary_edge_to_element
return self.edges
def GetInteriorEdgesPent(self):
"""Computes interior edges of a pentagonal mesh
returns:
interior_faces ndarray of interior edges
edge_flags ndarray of edge flags: 0 for interior and 1 for boundary
"""
if not isinstance(self.all_edges,np.ndarray):
self.GetEdgesPent()
if not isinstance(self.edges,np.ndarray):
self.GetBoundaryEdgesPent()
sorted_all_edges = np.sort(self.all_edges,axis=1)
sorted_boundary_edges = np.sort(self.edges,axis=1)
x = []
for i in range(self.edges.shape[0]):
current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],
self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])
interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)
pos_interior_edges = np.where(interior_edges==0)[0]
if pos_interior_edges.shape[0] != 0:
x.append(pos_interior_edges)
edge_aranger = np.arange(self.all_edges.shape[0])
edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])
interior_edges = self.all_edges[edge_aranger,:]
# GET FLAGS FOR BOUNDRAY AND INTERIOR
edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)
edge_flags[edge_aranger] = 0
self.interior_edges = interior_edges
return interior_edges, edge_flags
def GetHighOrderMesh(self,p=1, silent=True, **kwargs):
"""Given a linear tri, tet, quad or hex mesh compute high order mesh based on it.
This is a static method linked to the HigherOrderMeshing module"""
if not isinstance(p,int):
raise ValueError("p must be an integer")
else:
if p < 1:
raise ValueError("Value of p={} is not acceptable. Provide p>=1.".format(p))
if self.degree is None:
self.InferPolynomialDegree()
C = p-1
if 'C' in kwargs.keys():
if kwargs['C'] != p - 1:
raise ValueError("Did not understand the specified interpolation degree of the mesh")
del kwargs['C']
# DO NOT COMPUTE IF ALREADY COMPUTED FOR THE SAME ORDER
if self.degree == None:
self.degree = self.InferPolynomialDegree()
if self.degree == p:
return
# SITUATIONS WHEN ANOTHER HIGH ORDER MESH IS REQUIRED, WITH ONE HIGH
# ORDER MESH ALREADY AVAILABLE
if self.degree != 1 and self.degree - 1 != C:
dum = self.GetLinearMesh(remap=True)
self.__dict__.update(dum.__dict__)
if not silent:
print('Generating p = '+str(C+1)+' mesh based on the linear mesh...')
t_mesh = time()
# BUILD A NEW MESH BASED ON THE LINEAR MESH
if self.element_type == 'line':
nmesh = HighOrderMeshLine(C,self,**kwargs)
if self.element_type == 'tri':
if self.edges is None:
self.GetBoundaryEdgesTri()
# nmesh = HighOrderMeshTri(C,self,**kwargs)
nmesh = HighOrderMeshTri_SEMISTABLE(C,self,**kwargs)
elif self.element_type == 'tet':
# nmesh = HighOrderMeshTet(C,self,**kwargs)
nmesh = HighOrderMeshTet_SEMISTABLE(C,self,**kwargs)
elif self.element_type == 'quad':
if self.edges is None:
self.GetBoundaryEdgesQuad()
nmesh = HighOrderMeshQuad(C,self,**kwargs)
elif self.element_type == 'hex':
nmesh = HighOrderMeshHex(C,self,**kwargs)
self.points = nmesh.points
self.elements = nmesh.elements.astype(np.uint64)
if isinstance(self.corners,np.ndarray):
# NOT NECESSARY BUT GENERIC
self.corners = nmesh.corners.astype(np.uint64)
if isinstance(self.edges,np.ndarray):
self.edges = nmesh.edges.astype(np.uint64)
if isinstance(self.faces,np.ndarray):
if isinstance(nmesh.faces,np.ndarray):
self.faces = nmesh.faces.astype(np.uint64)
self.nelem = nmesh.nelem
self.nnode = self.points.shape[0]
self.element_type = nmesh.info
self.degree = C+1
self.ChangeType()
if not silent:
print('Finished generating the high order mesh. Time taken', time()-t_mesh,'sec')
def EdgeLengths(self,which_edges='boundary'):
"""Computes length of edges, for 2D and 3D meshes
which_edges: [str] 'boundary' for boundary edges only
and 'all' for all edges
"""
assert self.points is not None
assert self.element_type is not None
lengths = None
if which_edges == 'boundary':
if self.edges is None:
self.GetBoundaryEdges()
edge_coords = self.points[self.edges[:,:2],:]
lengths = np.linalg.norm(edge_coords[:,1,:] - edge_coords[:,0,:],axis=1)
elif which_edges == 'all':
if self.all_edges is None:
self.GetEdges()
edge_coords = self.points[self.all_edges[:,:2],:]
lengths = np.linalg.norm(edge_coords[:,1,:] - edge_coords[:,0,:],axis=1)
return lengths
def Lengths(self,):
"""Computes length of all types of elements
"""
self.__do_essential_memebers_exist__()
if self.element_type == "line":
coords = self.points[self.elements[:,:2],:]
lengths = np.linalg.norm(coords[:,1,:] - coords[:,0,:],axis=1)
else:
self.GetEdges()
coord = self.all_edges
coords = self.points[self.elements[:,:2],:]
lengths = np.linalg.norm(coords[:,1,:] - coords[:,0,:],axis=1)
return lengths
def Areas(self, with_sign=False, gpoints=None):
"""Find areas of all 2D elements [tris, quads].
For 3D elements returns surface areas of all faces
input:
with_sign: [str] compute with/without sign
gpoints: [ndarray] given coordinates to use instead of
self.points
returns: 1D array of nelem x 1 containing areas
"""
assert self.elements is not None
assert self.element_type is not None
if gpoints is None:
assert self.points is not None
gpoints = self.points
if self.element_type == "tri":
points = np.ones((gpoints.shape[0],3),dtype=np.float64)
points[:,:2] = gpoints
# FIND AREAS OF ALL THE ELEMENTS
area = 0.5*np.linalg.det(points[self.elements[:,:3],:])
elif self.element_type == "quad":
# NODE ORDERING IS IRRELEVANT, AS IT IS THESE AREAS
# WHICH DETERMINE NODE ORDERING
# AREA OF QUAD ABCD = AREA OF ABC + AREA OF ACD
points = np.ones((gpoints.shape[0],3),dtype=np.float64)
points[:,:2] = gpoints
# FIND AREAS ABC
area0 = np.linalg.det(points[self.elements[:,:3],:])
# FIND AREAS ACD
area1 = np.linalg.det(points[self.elements[:,[0,2,3]],:])
# FIND AREAS OF ALL THE ELEMENTS
area = 0.5*(area0+area1)
elif self.element_type == "tet":
# GET ALL THE FACES
faces = self.GetFacesTet()
points = np.ones((gpoints.shape[0],3),dtype=np.float64)
points[:,:2]=gpoints[:,:2]
area0 = np.linalg.det(points[faces[:,:3],:])
points[:,:2]=gpoints[:,[2,0]]
area1 = np.linalg.det(points[faces[:,:3],:])
points[:,:2]=gpoints[:,[1,2]]
area2 = np.linalg.det(points[faces[:,:3],:])
area = 0.5*np.linalg.norm(area0+area1+area2)
elif self.element_type == "hex":
from Florence.Tensor import unique2d
C = self.InferPolynomialDegree() - 1
area = 0
node_arranger = NodeArrangementHex(C)[0]
for i in range(node_arranger.shape[0]):
# print node_arranger[i,:]
# AREA OF FACES
points = np.ones((gpoints.shape[0],3),dtype=np.float64)
if i==0 or i==1:
points[:,:2] = gpoints[:,:2]
elif i==2 or i==3:
points[:,:2] = gpoints[:,[0,2]]
elif i==4 or i==5:
points[:,:2] = gpoints[:,1:]
# FIND AREAS ABC
area0 = np.linalg.det(points[self.elements[:,node_arranger[i,:3]],:])
# FIND AREAS ACD
area1 = np.linalg.det(points[self.elements[:,node_arranger[i,1:]],:])
# FIND AREAS OF ALL THE ELEMENTS
area += 0.5*np.linalg.norm(area0+area1)
# print area
raise ValueError('Hex areas implementation requires further checks')
else:
raise NotImplementedError("Computing areas for", self.element_type, "elements not implemented yet")
if with_sign is False:
if self.element_type == "tri" or self.element_type == "quad":
area = np.abs(area)
elif self.element_type == "tet":
raise NotImplementedError('Numbering order of tetrahedral faces could not be determined')
return area
def Volumes(self, with_sign=False, gpoints=None):
"""Find Volumes of all 3D elements [tets, hexes]
input:
with_sign: [str] compute with/without sign
gpoints: [ndarray] given coordinates to use instead of
self.points
returns: 1D array of nelem x 1 containing volumes
"""
assert self.elements is not None
assert self.element_type is not None
if self.points.shape[1] == 2:
raise ValueError("2D mesh does not have volume")
if gpoints is None:
assert self.points is not None
gpoints = self.points
if self.element_type == "tet":
a = gpoints[self.elements[:,0],:]
b = gpoints[self.elements[:,1],:]
c = gpoints[self.elements[:,2],:]
d = gpoints[self.elements[:,3],:]
det_array = np.dstack((a-d,b-d,c-d))
# FIND VOLUME OF ALL THE ELEMENTS
volume = 1./6.*np.linalg.det(det_array)
elif self.element_type == "hex":
# Refer: https://en.wikipedia.org/wiki/Parallelepiped
a = gpoints[self.elements[:,0],:]
b = gpoints[self.elements[:,1],:]
c = gpoints[self.elements[:,3],:]
d = gpoints[self.elements[:,4],:]
det_array = np.dstack((b-a,c-a,d-a))
# FIND VOLUME OF ALL THE ELEMENTS
volume = np.linalg.det(det_array)
else:
raise NotImplementedError("Computing volumes for", self.element_type, "elements not implemented yet")
if with_sign is False:
volume = np.abs(volume)
return volume
def Sizes(self, with_sign=False):
"""Computes the size of elements for all element types.
This is a generic method that for 1D=lengths, for 2D=areas and for 3D=volumes.
It works for planar and curved elements
"""
self.__do_essential_memebers_exist__()
try:
from Florence import DisplacementFormulation
except ImportError:
raise ValueError("This functionality requires Florence's support")
if self.element_type != "line":
# FOR LINE ELEMENTS THIS APPROACH DOES NOT WORK AS JACOBIAN IS NOT WELL DEFINED
formulation = DisplacementFormulation(self)
sizes = np.zeros(self.nelem)
if not with_sign:
for elem in range(self.nelem):
LagrangeElemCoords = self.points[self.elements[elem,:],:]
sizes[elem] = formulation.GetVolume(formulation.function_spaces[0],
LagrangeElemCoords, LagrangeElemCoords, False, elem=elem)
else:
for elem in range(self.nelem):
LagrangeElemCoords = self.points[self.elements[elem,:],:]
sizes[elem] = formulation.GetSignedVolume(formulation.function_spaces[0],
LagrangeElemCoords, LagrangeElemCoords, False, elem=elem)
return sizes
else:
warn("Sizes of line elements could be incorrect if the mesh is curvilinear")
return self.Lengths()
def AspectRatios(self,algorithm='edge_based'):
"""Compute aspect ratio of the mesh element-by-element.
For 2D meshes aspect ratio is aspect ratio is defined as
the ratio of maximum edge length to minimum edge length.
For 3D meshes aspect ratio can be either length or area based.
input:
algorithm: [str] 'edge_based' or 'face_based'
returns:
aspect_ratio: [1D array] of size (self.nelem) containing aspect ratio of elements
"""
assert self.points is not None
assert self.element_type is not None
aspect_ratio = None
if algorithm == 'edge_based':
if self.element_type == "tri":
edge_coords = self.points[self.elements[:,:3],:]
AB = np.linalg.norm(edge_coords[:,1,:] - edge_coords[:,0,:],axis=1)
AC = np.linalg.norm(edge_coords[:,2,:] - edge_coords[:,0,:],axis=1)
BC = np.linalg.norm(edge_coords[:,2,:] - edge_coords[:,1,:],axis=1)
minimum = np.minimum(np.minimum(AB,AC),BC)
maximum = np.maximum(np.maximum(AB,AC),BC)
aspect_ratio = 1.0*maximum/minimum
elif self.element_type == "quad":
edge_coords = self.points[self.elements[:,:4],:]
AB = np.linalg.norm(edge_coords[:,1,:] - edge_coords[:,0,:],axis=1)
BC = np.linalg.norm(edge_coords[:,2,:] - edge_coords[:,1,:],axis=1)
CD = np.linalg.norm(edge_coords[:,3,:] - edge_coords[:,2,:],axis=1)
DA = np.linalg.norm(edge_coords[:,0,:] - edge_coords[:,3,:],axis=1)
minimum = np.minimum(np.minimum(np.minimum(AB,BC),CD),DA)
maximum = np.maximum(np.maximum(np.maximum(AB,BC),CD),DA)
aspect_ratio = 1.0*maximum/minimum
elif self.element_type == "tet":
edge_coords = self.points[self.elements[:,:4],:]
AB = np.linalg.norm(edge_coords[:,1,:] - edge_coords[:,0,:],axis=1)
AC = np.linalg.norm(edge_coords[:,2,:] - edge_coords[:,0,:],axis=1)
AD = np.linalg.norm(edge_coords[:,3,:] - edge_coords[:,0,:],axis=1)
BC = np.linalg.norm(edge_coords[:,2,:] - edge_coords[:,1,:],axis=1)
BD = np.linalg.norm(edge_coords[:,3,:] - edge_coords[:,1,:],axis=1)
CD = np.linalg.norm(edge_coords[:,3,:] - edge_coords[:,2,:],axis=1)
minimum = np.minimum(np.minimum(np.minimum(np.minimum(np.minimum(AB,AC),AD),BC),BD),CD)
maximum = np.maximum(np.maximum(np.maximum(np.maximum(np.maximum(AB,AC),AD),BC),BD),CD)
aspect_ratio = 1.0*maximum/minimum
elif self.element_type == "hex":
edge_coords = self.points[self.elements[:,:8],:]
AB = np.linalg.norm(edge_coords[:,1,:] - edge_coords[:,0,:],axis=1)
BC = np.linalg.norm(edge_coords[:,2,:] - edge_coords[:,1,:],axis=1)
CD = np.linalg.norm(edge_coords[:,3,:] - edge_coords[:,2,:],axis=1)
DA = np.linalg.norm(edge_coords[:,0,:] - edge_coords[:,3,:],axis=1)
minimum0 = np.minimum(np.minimum(np.minimum(AB,BC),CD),DA)
maximum0 = np.maximum(np.maximum(np.maximum(AB,BC),CD),DA)
AB = np.linalg.norm(edge_coords[:,5,:] - edge_coords[:,4,:],axis=1)
BC = np.linalg.norm(edge_coords[:,6,:] - edge_coords[:,5,:],axis=1)
CD = np.linalg.norm(edge_coords[:,7,:] - edge_coords[:,6,:],axis=1)
DA = np.linalg.norm(edge_coords[:,4,:] - edge_coords[:,7,:],axis=1)
minimum1 = np.minimum(np.minimum(np.minimum(AB,BC),CD),DA)
maximum1 = np.maximum(np.maximum(np.maximum(AB,BC),CD),DA)
AB = np.linalg.norm(edge_coords[:,4,:] - edge_coords[:,0,:],axis=1)
BC = np.linalg.norm(edge_coords[:,5,:] - edge_coords[:,1,:],axis=1)
CD = np.linalg.norm(edge_coords[:,6,:] - edge_coords[:,2,:],axis=1)
DA = np.linalg.norm(edge_coords[:,7,:] - edge_coords[:,3,:],axis=1)
minimum2 = np.minimum(np.minimum(np.minimum(AB,BC),CD),DA)
maximum2 = np.maximum(np.maximum(np.maximum(AB,BC),CD),DA)
minimum = np.minimum(minimum0,np.minimum(minimum1,minimum2))
maximum = np.maximum(maximum0,np.maximum(maximum1,maximum2))
aspect_ratio = 1.0*maximum/minimum
elif self.element_type == "line":
raise ValueError("Line elments do no have aspect ratio")
elif algorithm == 'face_based':
raise NotImplementedError("Face/area based aspect ratio is not implemented yet")
return aspect_ratio
def FaceNormals(self):
"""Computes outward unit normals on faces.
This is a generic method for all element types apart from lines. If the mesh is in 2D plane
then the unit outward normals will point in Z direction. If the mesh is quad or tri type but
in 3D plane, this will still compute the correct unit outward normals. outwardness can only
be guaranteed for volume meshes.
This method is different from the method self.Normals() as the latter can compute normals
for 1D/2D elements in-plane
"""
self.__do_memebers_exist__()
points = np.copy(self.points)
if points.shape[1] < 3:
dum = np.zeros((points.shape[0],3))
dum[:,:points.shape[1]] = points
points = dum
if self.element_type == "tet" or self.element_type == "hex":
faces = self.faces
elif self.element_type == "tri" or self.element_type == "quad":
faces = self.elements
else:
raise ValueError("Cannot compute face normals on {}".format(self.element_type))
face_coords = self.points[faces[:,:3],:]
p1p0 = face_coords[:,1,:] - face_coords[:,0,:]
p2p0 = face_coords[:,2,:] - face_coords[:,0,:]
normals = np.cross(p1p0,p2p0)
norm_normals = np.linalg.norm(normals,axis=1)
normals[:,0] /= norm_normals
normals[:,1] /= norm_normals
normals[:,2] /= norm_normals
# CHECK IF THE NORMAL IS OUTWARD - FOR LINES DIRECTIONALITY DOES NOT MATTER
if self.element_type == "tet" or self.element_type == "hex":
self.GetElementsWithBoundaryFaces()
meds = self.Medians()
face_element_meds = meds[self.boundary_face_to_element[:,0],:]
p1pm = face_coords[:,1,:] - face_element_meds
# IF THE DOT PROUCT OF NORMALS AND EDGE-MED NODE VECTOR IS NEGATIVE THEN FLIP
_check = np.einsum("ij,ij->i",normals,p1pm)
normals[np.less(_check,0.)] = -normals[np.less(_check,0.)]
return normals
def Normals(self, show_plot=False):
"""Computes unit outward normals to the boundary for all element types.
Unity and outwardness are guaranteed
"""
self.__do_memebers_exist__()
ndim = self.InferSpatialDimension()
if self.element_type == "tet" or self.element_type == "hex":
normals = self.FaceNormals()
elif self.element_type == "tri" or self.element_type == "quad" or self.element_type == "line":
if self.points.shape[1] == 3:
normals = self.FaceNormals()
else:
if self.element_type == "tri" or self.element_type == "quad":
edges = self.edges
elif self.element_type == "line":
edges = self.elements
edge_coords = self.points[edges[:,:2],:]
p1p0 = edge_coords[:,1,:] - edge_coords[:,0,:]
normals = np.zeros_like(p1p0)
normals[:,0] = -p1p0[:,1]
normals[:,1] = p1p0[:,0]
norm_normals = np.linalg.norm(normals,axis=1)
normals[:,0] /= norm_normals
normals[:,1] /= norm_normals
# CHECK IF THE NORMAL IS OUTWARD - FOR LINES DIRECTIONALITY DOES NOT MATTER
if self.element_type == "tri" or self.element_type == "quad":
self.GetElementsWithBoundaryEdges()
meds = self.Medians()
edge_element_meds = meds[self.boundary_edge_to_element[:,0],:]
p1pm = edge_coords[:,1,:] - edge_element_meds
# IF THE DOT PROUCT OF NORMALS AND EDGE-MED NODE VECTOR IS NEGATIVE THEN FLIP
_check = np.einsum("ij,ij->i",normals,p1pm)
normals[np.less(_check,0.)] = -normals[np.less(_check,0.)]
if show_plot:
if ndim == 2:
mid_edge_coords = 0.5*(edge_coords[:,1,:] + edge_coords[:,0,:])
import matplotlib.pyplot as plt
figure = plt.figure()
self.SimplePlot(figure=figure, show_plot=False)
q = plt.quiver(mid_edge_coords[:,0], mid_edge_coords[:,1],
normals[:,0], normals[:,1],
color='Teal', headlength=5, width=0.004)
plt.axis('equal')
plt.axis('off')
plt.tight_layout()
plt.show()
elif ndim == 3:
mid_face_coords = np.sum(self.points[self.faces,:3],axis=1)/self.faces.shape[1]
import os
os.environ['ETS_TOOLKIT'] = 'qt4'
from mayavi import mlab
figure = mlab.figure(bgcolor=(1,1,1),fgcolor=(1,1,1),size=(1000,800))
self.SimplePlot(figure=figure, show_plot=False)
mlab.quiver3d(mid_face_coords[:,0], mid_face_coords[:,1], mid_face_coords[:,2],
normals[:,0], normals[:,1], normals[:,2],
color=(0.,128./255,128./255),line_width=2)
mlab.show()
return normals
def Angles(self, degrees=True):
"""Compute angles of 2D meshes. Strictly 2D meshes and linear elements.
If the mesh is curved the angles would be inaccurate
input:
degrees [bool] if True returns angles in degrees
otherwise in radians
returns:
angles [2D array] of angles per element. Angles are
computed per element so every element will
have as many angles as it's nodes
"""
self.__do_essential_memebers_exist__()
if self.InferElementalDimension() != 2:
raise ValueError("Angles can be computed only for 2D elements")
if self.InferSpatialDimension() != 2:
raise ValueError("Angles can be computed only in 2-dimensional plane")
nodeperelem = self.InferNumberOfNodesPerLinearElement()
angles = np.zeros((self.nelem, nodeperelem))
norm = lambda x: np.linalg.norm(x,axis=1)
edge_coords = self.points[self.elements[:,:],:]
if self.element_type == "tri":
AB = edge_coords[:,1,:] - edge_coords[:,0,:]
AC = edge_coords[:,2,:] - edge_coords[:,0,:]
BC = edge_coords[:,2,:] - edge_coords[:,1,:]
angles[:,0] = np.einsum("ij,ij->i",AB,AC) / (norm(AB)*norm(AC))
angles[:,1] = np.einsum("ij,ij->i",AC,BC) / (norm(AC)*norm(BC))
angles[:,2] = np.einsum("ij,ij->i",BC,-AB)/ (norm(BC)*norm(AB))
angles = np.arccos(angles)
elif self.element_type == "quad":
AB = edge_coords[:,1,:] - edge_coords[:,0,:]
BC = edge_coords[:,2,:] - edge_coords[:,1,:]
CD = edge_coords[:,3,:] - edge_coords[:,2,:]
DA = edge_coords[:,0,:] - edge_coords[:,3,:]
angles[:,0] = np.einsum("ij,ij->i",AB,BC) / (norm(AB)*norm(BC))
angles[:,1] = np.einsum("ij,ij->i",BC,CD) / (norm(BC)*norm(CD))
angles[:,2] = np.einsum("ij,ij->i",CD,DA) / (norm(CD)*norm(DA))
angles[:,3] = np.einsum("ij,ij->i",DA,-AB)/ (norm(DA)*norm(AB))
angles = np.arccos(angles)
if degrees:
angles *= 180/np.pi
return angles
def BoundingBoxes(self, show_plot=False, figure=None):
"""Computes a bounding box for every element.
This method complements the Bounds method/property in that it computes
the bounds for every individual element
returns:
bboxes [3D array] of nelem x ndim x ndim of bounding
boxes for every element
"""
self.__do_essential_memebers_exist__()
ndim = self.InferSpatialDimension()
all_elem_coords = self.points[self.elements]
mins = all_elem_coords.min(axis=1)
maxs = all_elem_coords.max(axis=1)
bboxes = np.zeros((2*self.nelem,self.points.shape[1]))
bboxes[::2] = mins
bboxes[1::2] = maxs
bboxes = bboxes.reshape(self.nelem,2,self.points.shape[1])
if show_plot:
if ndim == 3:
point_generator = lambda bbox: np.array([
[ bbox[0,0], bbox[0,1], bbox[0,2] ],
[ bbox[1,0], bbox[0,1], bbox[0,2] ],
[ bbox[1,0], bbox[1,1], bbox[0,2] ],
[ bbox[0,0], bbox[1,1], bbox[0,2] ],
[ bbox[0,0], bbox[0,1], bbox[1,2] ],
[ bbox[1,0], bbox[0,1], bbox[1,2] ],
[ bbox[1,0], bbox[1,1], bbox[1,2] ],
[ bbox[0,0], bbox[1,1], bbox[1,2] ]
])
elif ndim == 2:
point_generator = lambda bbox: np.array([
[ bbox[0,0], bbox[0,1] ],
[ bbox[1,0], bbox[0,1] ],
[ bbox[1,0], bbox[1,1] ],
[ bbox[0,0], bbox[1,1] ]
])
nsize = 4 if ndim ==2 else 8
ranger = np.arange(nsize)
bmesh = Mesh()
bmesh.element_type = "quad" if ndim ==2 else "hex"
bmesh.elements = np.arange(self.nelem*nsize).reshape(self.nelem,nsize)
bmesh.points = np.zeros((self.nelem*nsize,ndim))
bmesh.nelem = self.nelem
bmesh.nnode = bmesh.points.shape[0]
for i in range(0,self.nelem):
bmesh.points[i*nsize:(i+1)*nsize,:] = point_generator(bboxes[i])
if ndim == 2:
import matplotlib.pyplot as plt
if figure is None:
figure = plt.figure()
self.SimplePlot(figure=figure, show_plot=False)
bmesh.SimplePlot(figure=figure, show_plot=False, edge_color='r')
plt.show()
else:
import os
os.environ['ETS_TOOLKIT'] = 'qt4'
from mayavi import mlab
if figure is None:
figure = mlab.figure(bgcolor=(1,1,1),fgcolor=(1,1,1),size=(1000,800))
self.SimplePlot(figure=figure, show_plot=False)
bmesh.SimplePlot(figure=figure, show_plot=False, plot_faces=False, edge_color='r')
mlab.show()
return bboxes
def Medians(self, geometric=True):
"""Computes median of the elements tri, tet, quad, hex based on the interpolation function
input:
geometric [Bool] geometrically computes median without relying on FEM bases
retruns:
median: [ndarray] of median of elements
bases_at_median: [1D array] of (p=1) bases at median
"""
self.__do_essential_memebers_exist__()
median = None
if geometric == True:
median = np.sum(self.points[self.elements,:],axis=1)/self.elements.shape[1]
return median
else:
try:
from Florence.FunctionSpace import Tri, Tet
from Florence.QuadratureRules import FeketePointsTri, FeketePointsTet
except ImportError:
raise ImportError("This functionality requires florence's support")
if self.element_type == "tri":
eps = FeketePointsTri(2)
middle_point_isoparametric = eps[6,:]
if not np.isclose(sum(middle_point_isoparametric),-0.6666666):
raise ValueError("Median of triangle does not match [-0.3333,-0.3333]. "
"Did you change your nodal spacing or interpolation functions?")
hpBases = Tri.hpNodal.hpBases
bases_for_middle_point = hpBases(0,middle_point_isoparametric[0],
middle_point_isoparametric[1])[0]
median = np.einsum('ijk,j',self.points[self.elements[:,:3],:],bases_for_middle_point)
elif self.element_type == "tet":
middle_point_isoparametric = FeketePointsTet(3)[21]
if not np.isclose(sum(middle_point_isoparametric),-1.5):
raise ValueError("Median of tetrahedral does not match [-0.5,-0.5,-0.5]. "
"Did you change your nodal spacing or interpolation functions?")
# C = self.InferPolynomialDegree() - 1
hpBases = Tet.hpNodal.hpBases
bases_for_middle_point = hpBases(0,middle_point_isoparametric[0],
middle_point_isoparametric[1],middle_point_isoparametric[2])[0]
median = np.einsum('ijk,j',self.points[self.elements[:,:4],:],bases_for_middle_point)
else:
raise NotImplementedError('Median for {} elements not implemented yet'.format(self.element_type))
return median, bases_for_middle_point
def FindElementContainingPoint(self, point, algorithm="fem", find_parametric_coordinate=True,
scaling_factor=5., tolerance=1.0e-7, maxiter=20, use_simple_bases=False, return_on_geometric_finds=False,
initial_guess=None, initial_guesses=None, restart=False):
"""Find which element does a point lie in using specificed algorithm.
The FEM isoparametric coordinate of the point is returned as well.
If the isoparametric coordinate of the point is not required, issue find_parametric_coordinate=False
input:
point: [tuple] XYZ of enquiry point
algorithm: [str] either 'fem' or 'geometric'. The 'fem' algorithm uses k-d tree
search to get the right bounding box around as few elements as possible.
The size of the box can be specified by the user through the keyword scaling_factor.
The geometric algorithm is a lot more stable and converges much quicker.
The geomtric algorithm first identifies the right element using volume check,
then tries all possible combination of initial guesses to get the FEM
isoparametric point. Trying all possible combination with FEM can be potentially
more costly since bounding box size can be large.
return_on_geometric_finds:
[bool] if geometric algorithm is chosen and this option is on, then it returns
the indices of elements as soon as the volume check and no further checks are
done. This is useful for situations when searching for points that are meant to
be in the interior of the elements rather than at the boundaries or nodes
otherwise the number of elements returned by geometric algorithm is going to be
more than one
return:
element_index [int/1D array of ints] element(s) containing the point.
If the point is shared between many elements a 1D array is returned
iso_parametric_point [1D array] the parametric coordinate of the point within the element.
return only if find_parametric_coordinate=True
"""
if restart:
if initial_guesses is None:
if self.element_type == "pent":
initial_guesses = np.array([
[0.,0.],
[1.,0.],
[1.,0.5],
[0.5,1.],
[0.,1.],
])
else:
raise ValueError("restart option for this element type is only supported if initial_guesses are available")
for i in range(initial_guesses.shape[0]):
ret_val = self.FindElementContainingPoint(point, algorithm=algorithm,
find_parametric_coordinate=find_parametric_coordinate,
scaling_factor=scaling_factor, tolerance=tolerance, maxiter=maxiter,
use_simple_bases=use_simple_bases, return_on_geometric_finds=return_on_geometric_finds,
initial_guess=initial_guesses[i,:], restart=False)
if ret_val[1] is not None:
break
return ret_val
self.__do_essential_memebers_exist__()
C = self.InferPolynomialDegree() - 1
if C > 0:
warn("Note that finding a point within higher order curved mesh is not supported yet")
if C > 0 and algorithm == "geometric":
warn("High order meshes are not supported using geometric algorithim. I am going to operate on linear mesh")
if use_simple_bases:
raise ValueError("Simple bases for high order elements are not available")
return
ndim = self.InferSpatialDimension()
assert len(point) == ndim
from Florence.FunctionSpace import PointInversionIsoparametricFEM
candidate_element, candidate_piso = None, None
if self.element_type == "tet" and algorithm == "fem":
algorithm = "geometric"
if algorithm == "fem":
scaling_factor = float(scaling_factor)
max_h = self.EdgeLengths().max()
# max_h=1.
# FOR CURVED ELEMENTS
# max_h = self.LargestSegment().max()
# GET A BOUNDING BOX AROUND THE POINT, n TIMES LARGER THAN MAXIMUM h, WHERE n is the SCALING FACTOR
if ndim==3:
bounding_box = (point[0]-scaling_factor*max_h,
point[1]-scaling_factor*max_h,
point[2]-scaling_factor*max_h,
point[0]+scaling_factor*max_h,
point[1]+scaling_factor*max_h,
point[2]+scaling_factor*max_h)
elif ndim==2:
bounding_box = (point[0]-scaling_factor*max_h,
point[1]-scaling_factor*max_h,
point[0]+scaling_factor*max_h,
point[1]+scaling_factor*max_h)
# SELECT ELEMENTS ONLY WITHIN THE BOUNDING BOX
mesh = deepcopy(self)
idx_kept_element = self.RemoveElements(bounding_box)[1]
if ndim==3:
for i in range(self.nelem):
coord = self.points[self.elements[i,:],:]
p_iso, converged = PointInversionIsoparametricFEM(self.element_type, C, coord, point,
tolerance=tolerance, maxiter=maxiter, verbose=True, use_simple_bases=use_simple_bases,
initial_guess=initial_guess)
if converged:
# if p_iso[0] >= -1. and p_iso[0] <=1. and \
# p_iso[1] >= -1. and p_iso[1] <=1. and \
# p_iso[2] >= -1. and p_iso[2] <=1. :
if (p_iso[0] > -1. or np.isclose(p_iso[0],-1.,rtol=tolerance)) and \
(p_iso[0] < 1. or np.isclose(p_iso[0], 1.,rtol=tolerance)) and \
(p_iso[1] > -1. or np.isclose(p_iso[1],-1.,rtol=tolerance)) and \
(p_iso[1] < 1. or np.isclose(p_iso[1],-1.,rtol=tolerance)) and \
(p_iso[2] > -1. or np.isclose(p_iso[2],-1.,rtol=tolerance)) and \
(p_iso[2] < 1. or np.isclose(p_iso[2], 1.,rtol=tolerance)) :
candidate_element, candidate_piso = i, p_iso
break
elif ndim==2:
for i in range(self.nelem):
coord = self.points[self.elements[i,:],:]
p_iso, converged = PointInversionIsoparametricFEM(self.element_type, C, coord, point,
tolerance=tolerance, maxiter=maxiter, verbose=True, use_simple_bases=use_simple_bases,
initial_guess=initial_guess)
# if p_iso[0] >= -1. and p_iso[0] <=1. and \
# p_iso[1] >= -1. and p_iso[1] <=1.:
# candidate_element, candidate_piso = i, p_iso
# break
if (p_iso[0] > -1. or np.isclose(p_iso[0],-1.,rtol=tolerance)) and \
(p_iso[0] < 1. or np.isclose(p_iso[0], 1.,rtol=tolerance)) and \
(p_iso[1] > -1. or np.isclose(p_iso[1],-1.,rtol=tolerance)) and \
(p_iso[1] < 1. or np.isclose(p_iso[1],-1.,rtol=tolerance)) :
candidate_element, candidate_piso = i, p_iso
break
self.__update__(mesh)
# print(candidate_element)
if candidate_element is not None:
candidate_element = idx_kept_element[candidate_element]
if find_parametric_coordinate:
return candidate_element, candidate_piso
else:
return candidate_element
else:
if self.element_type == "tet":
from Florence.QuadratureRules.FeketePointsTet import FeketePointsTet
initial_guesses = FeketePointsTet(C)
def GetVolTet(a0,b0,c0,d0):
det_array = np.dstack((a0-d0,b0-d0,c0-d0))
# FIND VOLUME OF ALL THE ELEMENTS
volume = 1./6.*np.abs(np.linalg.det(det_array))
return volume
a = self.points[self.elements[:,0],:]
b = self.points[self.elements[:,1],:]
c = self.points[self.elements[:,2],:]
d = self.points[self.elements[:,3],:]
o = np.tile(point,self.nelem).reshape(self.nelem,a.shape[1])
# TOTAL VOLUME
vol = self.Volumes()
# PARTS' VOLUMES
vol0 = GetVolTet(a,b,c,o)
vol1 = GetVolTet(a,b,o,d)
vol2 = GetVolTet(a,o,c,d)
vol3 = GetVolTet(o,b,c,d)
criterion_check = vol0+vol1+vol2+vol3-vol
elems = np.isclose(criterion_check,0.,rtol=tolerance)
elems_idx = np.where(elems==True)[0]
elif self.element_type == "quad":
from Florence.QuadratureRules.GaussLobattoPoints import GaussLobattoPointsQuad
initial_guesses = GaussLobattoPointsQuad(C)
def GetAreaQuad(a0,b0,c0,d0):
# AREA OF QUAD ABCD = AREA OF ABC + AREA OF ACD
a00 = np.ones((a0.shape[0],3),dtype=np.float64); a00[:,:2] = a0
b00 = np.ones((b0.shape[0],3),dtype=np.float64); b00[:,:2] = b0
c00 = np.ones((c0.shape[0],3),dtype=np.float64); c00[:,:2] = c0
d00 = np.ones((d0.shape[0],3),dtype=np.float64); d00[:,:2] = d0
# FIND AREAS ABC
area0 = np.abs(np.linalg.det(np.dstack((a00,b00,c00))))
# FIND AREAS ACD
area1 = np.abs(np.linalg.det(np.dstack((a00,c00,d00))))
# FIND AREAS OF ALL THE ELEMENTS
area = 0.5*(area0+area1)
return area
a = self.points[self.elements[:,0],:]
b = self.points[self.elements[:,1],:]
c = self.points[self.elements[:,2],:]
d = self.points[self.elements[:,3],:]
o = np.tile(point,self.nelem).reshape(self.nelem,a.shape[1])
# TOTAL VOLUME
vol = self.Areas()
# PARTS' VOLUMES - DONT CHANGE THE ORDERING OF SPECIALLY vol1
vol0 = GetAreaQuad(o,c,b,a)
vol1 = GetAreaQuad(o,a,d,c)
criterion_check = vol0+vol1-vol
elems = np.isclose(criterion_check,0.,rtol=tolerance)
elems_idx = np.where(elems==True)[0]
else:
raise NotImplementedError("Geometric algorithm for {} elements not implemented yet".format(self.element_type))
if return_on_geometric_finds:
return elems_idx
for i in range(len(elems_idx)):
coord = self.points[self.elements[elems_idx[i],:],:]
# TRY ALL POSSIBLE INITIAL GUESSES - THIS IS CHEAP AS THE SEARCH SPACE CONTAINS ONLY A
# FEW ELEMENTS
for guess in initial_guesses:
p_iso, converged = PointInversionIsoparametricFEM(self.element_type, C, coord, point,
tolerance=tolerance, maxiter=maxiter, verbose=True,
use_simple_bases=use_simple_bases, initial_guess=guess)
if converged:
break
if converged:
candidate_element, candidate_piso = elems_idx[i], p_iso
break
if find_parametric_coordinate:
return candidate_element, candidate_piso
else:
return candidate_element
def AverageJacobian(self):
"""Computes average Jacobian of elements for all element types over a mesh
This is a generic method that for 1D=lengths, for 2D=areas and for 3D=volumes.
It works for planar and curved elements
"""
self.__do_essential_memebers_exist__()
try:
from Florence import DisplacementFormulation
except ImportError:
raise ValueError("This functionality requires Florence's support")
if self.element_type != "line":
# FOR LINE ELEMENTS THIS APPROACH DOES NOT WORK AS JACOBIAN IS NOT WELL DEFINED
formulation = DisplacementFormulation(self)
sizes = np.zeros(self.nelem)
for elem in range(self.nelem):
LagrangeElemCoords = self.points[self.elements[elem,:],:]
sizes[elem] = formulation.GetAverageJacobian(formulation.function_spaces[0],
LagrangeElemCoords, LagrangeElemCoords, False, elem=elem)
return sizes.mean()
else:
raise ValueError("Not implemented for 1D elements")
def LargestSegment(self, smallest_element=True, nsamples=30,
plot_segment=False, plot_element=False, figure=None, save=False, filename=None):
"""Finds the largest segment that can fit in an element. For curvilinear elements
this measure can be used as (h) for h-refinement studies
input:
smallest_element [bool] if the largest segment size is to be computed in the
smallest element (i.e. element with the smallest area in 2D or
smallest volume in 3D). Default is True. If False, then the largest
segment in the largest element will be computed.
nsample: [int] number of sample points along the curved
edges of the elements. The maximum distance between
all combinations of these points is the largest
segment
plot_segment: [bool] plots segment on tope of [curved/straight] mesh
plot_element: [bool] plots the straight/curved element to which the segment
belongs
figure: [an instance of matplotlib/mayavi.mlab figure for 2D/3D]
save: [bool] wether to save the figure or not
filename: [str] file name for the figure to be save
returns:
largest_segment_length [float] maximum segment length that could be fit within either the
"""
self.__do_memebers_exist__()
if self.element_type == "hex" or self.element_type == "tet":
quantity = self.Volumes()
elif self.element_type == "quad" or self.element_type == "tri":
quantity = self.Areas()
if smallest_element:
omesh = self.GetLocalisedMesh(quantity.argmin())
else:
omesh = self.GetLocalisedMesh(quantity.argmax())
try:
from Florence.PostProcessing import PostProcess
except:
raise ImportError('This function requires florence PostProcessing module')
return
if save:
if filename is None:
raise ValueError("No file name provided. I am going to write one the current directory")
filename = PWD(__file__) + "/output.png"
if self.element_type == "tri":
tmesh = PostProcess.TessellateTris(omesh,np.zeros_like(omesh.points),
plot_edges=True, interpolation_degree=nsamples)
elif self.element_type == "quad":
tmesh = PostProcess.TessellateQuads(omesh,np.zeros_like(omesh.points),
plot_edges=True, interpolation_degree=nsamples)
elif self.element_type == "tet":
tmesh = PostProcess.TessellateTets(omesh,np.zeros_like(omesh.points),
plot_edges=True, interpolation_degree=nsamples)
elif self.element_type == "hex":
tmesh = PostProcess.TessellateHexes(omesh,np.zeros_like(omesh.points),
plot_edges=True, interpolation_degree=nsamples)
ndim = omesh.InferSpatialDimension()
nnode = tmesh.points.shape[0]
largest_segment_lengths = []
nodes = np.array((1,ndim))
for i in range(nnode):
tiled_points = np.tile(tmesh.points[i,:][:,None],nnode).T
segment_lengths = np.linalg.norm(tmesh.points - tiled_points, axis=1)
largest_segment_lengths.append(segment_lengths.max())
nodes = np.vstack((nodes, np.array([i,segment_lengths.argmax()])[None,:]))
largest_segment_lengths = np.array(largest_segment_lengths)
nodes = nodes[1:,:]
largest_segment_length = largest_segment_lengths.max()
corresponding_nodes = nodes[largest_segment_lengths.argmax(),:]
if plot_segment:
segment_coords = tmesh.points[corresponding_nodes,:]
if ndim==2:
import matplotlib.pyplot as plt
if figure == None:
figure = plt.figure()
if plot_element:
if omesh.element_type == "tri":
PostProcess.CurvilinearPlotTri(omesh,
np.zeros_like(omesh.points),plot_points=True,
figure=figure, interpolation_degree=nsamples, show_plot=False)
elif omesh.element_type == "quad":
PostProcess.CurvilinearPlotQuad(omesh,
np.zeros_like(omesh.points),plot_points=True,
figure=figure, interpolation_degree=nsamples, show_plot=False)
tmesh.SimplePlot(figure=figure,show_plot=False)
if save:
plt.savefig(filename,bbox_inches="tight",dpi=300)
plt.show()
elif ndim==3:
import os
os.environ['ETS_TOOLKIT'] = 'qt4'
from mayavi import mlab
if figure is None:
figure = mlab.figure(bgcolor=(1,1,1),fgcolor=(1,1,1),size=(1000,800))
if plot_element:
if omesh.element_type == "tet":
PostProcess.CurvilinearPlotTet(omesh,
np.zeros_like(omesh.points),plot_points=True, point_radius=0.13,
figure=figure, interpolation_degree=nsamples, show_plot=False)
elif omesh.element_type == "hex":
PostProcess.CurvilinearPlotHex(omesh,
np.zeros_like(omesh.points),plot_points=True,
figure=figure, interpolation_degree=nsamples, show_plot=False)
tmesh.GetEdges()
edge_coords = tmesh.points[np.unique(tmesh.all_edges),:]
mlab.triangular_mesh(tmesh.points[:,0],tmesh.points[:,1],tmesh.points[:,2],
tmesh.elements, representation='wireframe', color=(0,0,0))
# # mlab.points3d(edge_coords[:,0],edge_coords[:,1],edge_coords[:,2],color=(1., 99/255., 71./255), scale_factor=0.03)
# # mlab.plot3d(segment_coords[:,0],segment_coords[:,1],segment_coords[:,2], color=(227./255, 66./255, 52./255))
mlab.points3d(edge_coords[:,0],edge_coords[:,1],edge_coords[:,2],color=(1., 99/255., 71./255), scale_factor=0.17)
mlab.plot3d(segment_coords[:,0],segment_coords[:,1],segment_coords[:,2],
color=(227./255, 66./255, 52./255), line_width=10., representation="wireframe")
if save:
mlab.savefig(filename,dpi=300)
mlab.show()
return largest_segment_length
def CheckNodeNumbering(self,change_order_to='retain', verbose=True):
"""Checks for node numbering order of the imported mesh. Mesh can be tri or tet
input:
change_order_to: [str] {'clockwise','anti-clockwise','retain'} changes the order to clockwise,
anti-clockwise or retains the numbering order - default is 'retain'
output:
original_order: [str] {'clockwise','anti-clockwise','retain'} returns the original numbering order"""
self.__do_essential_memebers_exist__()
# CHECK IF IT IS LINEAR MESH
nodeperelem = self.InferNumberOfNodesPerLinearElement()
assert self.elements.shape[1] == nodeperelem
quantity = np.array([])
if self.element_type == "tri":
quantity = self.Areas(with_sign=True)
elif self.element_type == "quad":
quantity = self.Areas(with_sign=True)
elif self.element_type == "tet":
quantity = self.Volumes(with_sign=True)
elif self.element_type == "hex":
quantity = self.Volumes(with_sign=True)
original_order = ''
# CHECK NUMBERING
if (quantity > 0).all():
original_order = 'anti-clockwise'
if change_order_to == 'clockwise':
self.elements = np.fliplr(self.elements)
elif (quantity < 0).all():
original_order = 'clockwise'
if change_order_to == 'anti-clockwise':
self.elements = np.fliplr(self.elements)
else:
original_order = 'mixed'
if change_order_to == 'clockwise':
self.elements[quantity>0,:] = np.fliplr(self.elements[quantity>0,:])
elif change_order_to == 'anti-clockwise':
self.elements[quantity<0,:] = np.fliplr(self.elements[quantity<0,:])
if original_order == 'anti-clockwise':
print(u'\u2713'.encode('utf8')+b' : ','Imported mesh has',original_order,'node ordering')
else:
print(u'\u2717'.encode('utf8')+b' : ','Imported mesh has',original_order,'node ordering')
return original_order
def GetElementsEdgeNumberingTri(self):
"""Finds edges of elements and their flags saying which edge they are [0,1,2].
At most a triangle can have all its three edges on the boundary.
output:
edge_elements: [1D array] array containing elements which have edges
on the boundary
Note that this method sets the self.edge_to_element to edge_elements,
so the return value is not strictly necessary
"""
if isinstance(self.edge_to_element,np.ndarray):
if self.edge_to_element.shape[0] > 1:
return self.edge_to_element
# GET ALL EDGES FROM THE ELEMENT CONNECTIVITY
if self.all_edges is None:
self.GetEdgesTri()
all_edges = np.concatenate((self.elements[:,:2],self.elements[:,[1,2]],
self.elements[:,[2,0]]),axis=0).astype(np.int64)
all_edges, idx = unique2d(all_edges,consider_sort=True,order=False, return_index=True)
edge_elements = np.zeros((all_edges.shape[0],2),dtype=np.int64)
edge_elements[:,0] = idx % self.elements.shape[0]
edge_elements[:,1] = idx // self.elements.shape[0]
self.edge_to_element = edge_elements
return self.edge_to_element
def GetElementsWithBoundaryEdgesTri(self):
"""Finds elements which have edges on the boundary.
At most an element can have all its three edges on the boundary.
output:
edge_elements: [2D array] array containing elements which have edge
on the boundary [cloumn 0] and a flag stating which edges they are [column 1]
"""
if isinstance(self.boundary_edge_to_element,np.ndarray):
if self.boundary_edge_to_element.shape[1] > 1 and self.boundary_edge_to_element.shape[0] > 1:
return self.boundary_edge_to_element
# DO NOT COMPUTE EDGES AND RAISE BECAUSE OF CYCLIC DEPENDENCIES
assert self.elements is not None
assert self.edges is not None
edge_elements = np.zeros((self.edges.shape[0],2),dtype=np.int64)
# FIND WHICH FACE NODES ARE IN WHICH ELEMENT
for i in range(self.edges.shape[0]):
x = []
for j in range(2):
x.append(np.where(self.elements[:,:3]==self.edges[i,j])[0])
# FIND WHICH ELEMENTS CONTAIN ALL FACE NODES - FOR INTERIOR ELEMENTS
# THEIR CAN BE MORE THAN ONE ELEMENT CONTAINING ALL FACE NODES
z = x[0]
for k in range(1,len(x)):
z = np.intersect1d(x[k],z)
# CHOOSE ONLY ONE OF THESE ELEMENTS
edge_elements[i,0] = z[0]
# WHICH COLUMNS IN THAT ELEMENT ARE THE FACE NODES LOCATED
cols = np.array([np.where(self.elements[z[0],:]==self.edges[i,0])[0],
np.where(self.elements[z[0],:]==self.edges[i,1])[0]
])
cols = np.sort(cols.flatten())
if cols[0] == 0 and cols[1] == 1:
edge_elements[i,1] = 0
elif cols[0] == 1 and cols[1] == 2:
edge_elements[i,1] = 1
elif cols[0] == 0 and cols[1] == 2:
edge_elements[i,1] = 2
self.boundary_edge_to_element = edge_elements
return edge_elements
def GetElementsWithBoundaryFacesTet(self):
"""Finds elements which have faces on the boundary.
At most a tetrahedral element can have all its four faces on the boundary.
output:
boundary_face_to_element: [2D array] array containing elements which have face
on the boundary [column 0] and a flag stating which faces they are [column 1]
"""
if self.boundary_face_to_element is not None:
return self.boundary_face_to_element
# DO NOT COMPUTE FACES AND RAISE BECAUSE OF CYCLIC DEPENDENCIES
assert self.elements is not None
assert self.faces is not None
# THIS METHOD ALWAYS RETURNS THE FACE TO ELEMENT ARRAY, AND DOES NOT CHECK
# IF THIS HAS BEEN COMPUTED BEFORE, THE REASON BEING THAT THE FACES CAN COME
# EXTERNALLY WHOSE ARRANGEMENT WOULD NOT CORRESPOND TO THE ONE USED INTERNALLY
# HENCE THIS MAPPING BECOMES NECESSARY
all_faces = np.concatenate((self.elements[:,:3],self.elements[:,[0,1,3]],
self.elements[:,[0,2,3]],self.elements[:,[1,2,3]]),axis=0).astype(self.faces.dtype)
all_faces_in_faces = in2d(all_faces,self.faces[:,:3],consider_sort=True)
all_faces_in_faces = np.where(all_faces_in_faces==True)[0]
boundary_face_to_element = np.zeros((all_faces_in_faces.shape[0],2),dtype=np.int64)
boundary_face_to_element[:,0] = all_faces_in_faces % self.elements.shape[0]
boundary_face_to_element[:,1] = all_faces_in_faces // self.elements.shape[0]
# SO FAR WE HAVE COMPUTED THE ELEMENTS THAT CONTAIN FACES, HOWEVER
# NOTE THAT WE STILL HAVE NOT COMPUTED A MAPPING BETWEEN ELEMENTS AND
# FACES. WE ONLY KNOW WHICH ELEMENTS CONTAIN FACES FROM in2d.
# WE NEED TO FIND THIS MAPPING NOW
C = self.InferPolynomialDegree() - 1
node_arranger = NodeArrangementTet(C)[0]
# WE NEED TO DO THIS DUMMY RECONSTRUCTION OF FACES BASED ON ELEMENTS
faces = self.elements[boundary_face_to_element[:,0][:,None],
node_arranger[boundary_face_to_element[:,1],:]].astype(self.faces.dtype)
# CHECK FOR THIS CONDITION AS ARRANGEMENT IS NO LONGER MAINTAINED
assert np.sum(faces[:,:3].astype(np.int64) - self.faces[:,:3].astype(np.int64)) == 0
# NOW GET THE ROW MAPPING BETWEEN OLD FACES AND NEW FACES
from Florence.Tensor import shuffle_along_axis
row_mapper = shuffle_along_axis(faces[:,:3],self.faces[:,:3],consider_sort=True)
# UPDATE THE MAP
boundary_face_to_element[:,:] = boundary_face_to_element[row_mapper,:]
self.boundary_face_to_element = boundary_face_to_element
return self.boundary_face_to_element
def GetElementsFaceNumberingTet(self):
"""Finds which faces belong to which elements and which faces of the elements
they are e.g. 0, 1, 2 or 3.
output:
face_elements: [2D array] nfaces x 2 array containing elements which have face
on the boundary with their flags
Note that this method also sets the self.face_to_element to face_elements,
so the return value is not strictly necessary
"""
if isinstance(self.face_to_element,np.ndarray):
if self.face_to_element.shape[0] > 1:
return self.face_to_element
assert self.elements is not None
# GET ALL FACES FROM ELEMENT CONNECTIVITY
if self.all_faces is None:
self.GetFacesTet()
all_faces = np.concatenate((self.elements[:,:3],self.elements[:,[0,1,3]],
self.elements[:,[0,2,3]],self.elements[:,[1,2,3]]),axis=0).astype(np.int64)
_,idx = unique2d(all_faces,consider_sort=True,order=False, return_index=True)
face_elements = np.zeros((self.all_faces.shape[0],2),dtype=np.int64)
face_elements[:,0] = idx % self.elements.shape[0]
face_elements[:,1] = idx // self.elements.shape[0]
self.face_to_element = face_elements
return self.face_to_element
def ArrangeFacesTet(self):
"""Arranges all the faces of tetrahedral elements
with triangular type node ordering """
if self.all_faces is None:
self.all_faces = self.GetFacesTet()
if self.face_to_element is None:
self.GetElementsFaceNumberingTet()
# DETERMINE DEGREE
p = self.InferPolynomialDegree()
node_arranger = NodeArrangementTet(p-1)[0]
# for i in range(self.face_to_element.shape[0]):
# self.all_faces = self.elements[self.face_to_element[i,0],node_arranger[self.face_to_element[i,1],:]]
self.all_faces = self.elements[self.face_to_element[:,0][:,None],node_arranger[self.face_to_element[:,1],:]]
def GetElementsEdgeNumberingQuad(self):
"""Finds edges of elements and their flags saying which edge they are [0,1,2,3].
At most a quad can have all its four edges on the boundary.
output:
edge_elements: [1D array] array containing elements which have edges
on the boundary
Note that this method sets the self.edge_to_element to edge_elements,
so the return value is not strictly necessary
"""
if isinstance(self.edge_to_element,np.ndarray):
if self.edge_to_element.shape[0] > 1:
return self.edge_to_element
# GET ALL EDGES FROM THE ELEMENT CONNECTIVITY
if self.all_edges is None:
self.GetEdgesQuad()
p = self.InferPolynomialDegree()
# FIND WHICH FACE NODES ARE IN WHICH ELEMENT
node_arranger = NodeArrangementQuad(p-1)[0]
# GET ALL EDGES FROM THE ELEMENT CONNECTIVITY
all_edges = np.concatenate((self.elements[:,node_arranger[0,:]],self.elements[:,node_arranger[1,:]],
self.elements[:,node_arranger[2,:]],self.elements[:,node_arranger[3,:]]),axis=0).astype(np.int64)
all_edges, idx = unique2d(all_edges,consider_sort=True,order=False, return_index=True)
edge_elements = np.zeros((all_edges.shape[0],2),dtype=np.int64)
# edge_elements = np.zeros((self.edges.shape[0],2),dtype=np.int64)
edge_elements[:,0] = idx % self.elements.shape[0]
edge_elements[:,1] = idx // self.elements.shape[0]
self.edge_to_element = edge_elements
return self.edge_to_element
def GetElementsWithBoundaryEdgesQuad(self):
"""Finds elements which have edges on the boundary.
At most a quad can have all its four edges on the boundary.
output:
boundary_edge_to_element: [2D array] array containing elements which have face
on the boundary [cloumn 0] and a flag stating which edges they are [column 1]
"""
if isinstance(self.boundary_edge_to_element,np.ndarray):
if self.boundary_edge_to_element.shape[1] > 1 and self.boundary_edge_to_element.shape[0] > 1:
return self.boundary_edge_to_element
# DO NOT COMPUTE EDGES AND RAISE BECAUSE OF CYCLIC DEPENDENCIES
assert self.elements is not None
assert self.edges is not None
p = self.InferPolynomialDegree()
# FIND WHICH FACE NODES ARE IN WHICH ELEMENT
node_arranger = NodeArrangementQuad(p-1)[0]
# GET ALL EDGES FROM THE ELEMENT CONNECTIVITY
all_edges = np.concatenate((self.elements[:,node_arranger[0,:]],self.elements[:,node_arranger[1,:]],
self.elements[:,node_arranger[2,:]],self.elements[:,node_arranger[3,:]]),axis=0).astype(self.edges.dtype)
# GET UNIQUE ROWS
uniques, idx, inv = unique2d(all_edges,consider_sort=True,order=False,return_index=True,return_inverse=True)
# ROWS THAT APPEAR ONLY ONCE CORRESPOND TO BOUNDARY EDGES
freqs_inv = itemfreq(inv)
edges_ext_flags = freqs_inv[freqs_inv[:,1]==1,0]
# NOT ARRANGED
edges = uniques[edges_ext_flags,:]
# DETERMINE WHICH FACE OF THE ELEMENT THEY ARE
boundary_edge_to_element = np.zeros((edges_ext_flags.shape[0],2),dtype=np.int64)
# FURTHER RE-ARRANGEMENT / ARANGE THE NODES BASED ON THE ORDER THEY APPEAR
# IN ELEMENT CONNECTIVITY
# THIS STEP IS NOT NECESSARY INDEED - ITS JUST FOR RE-ARANGMENT OF EDGES
all_edges_in_edges = in2d(all_edges,self.edges,consider_sort=True)
all_edges_in_edges = np.where(all_edges_in_edges==True)[0]
boundary_edge_to_element[:,0] = all_edges_in_edges % self.elements.shape[0]
boundary_edge_to_element[:,1] = all_edges_in_edges // self.elements.shape[0]
# ARRANGE FOR ANY ORDER OF BASES/ELEMENTS AND ASSIGN DATA MEMBERS
self.boundary_edge_to_element = boundary_edge_to_element
return self.boundary_edge_to_element
def GetElementsWithBoundaryFacesHex(self):
"""Finds elements which have faces on the boundary.
At most a hexahedral can have all its 8 faces on the boundary.
output:
boundary_face_to_element: [2D array] array containing elements which have face
on the boundary [column 0] and a flag stating which faces they are [column 1]
"""
# DO NOT COMPUTE FACES AND RAISE BECAUSE OF CYCLIC DEPENDENCIES
assert self.elements is not None
assert self.faces is not None
if self.boundary_face_to_element is not None:
return self.boundary_face_to_element
# THIS METHOD ALWAYS RETURNS THE FACE TO ELEMENT ARRAY, AND DOES NOT CHECK
# IF THIS HAS BEEN COMPUTED BEFORE, THE REASON BEING THAT THE FACES CAN COME
# EXTERNALLY WHOSE ARRANGEMENT WOULD NOT CORRESPOND TO THE ONE USED INTERNALLY
# HENCE THIS MAPPING BECOMES NECESSARY
C = self.InferPolynomialDegree() - 1
node_arranger = NodeArrangementHex(C)[0]
all_faces = np.concatenate((np.concatenate((
np.concatenate((np.concatenate((np.concatenate((self.elements[:,node_arranger[0,:]],
self.elements[:,node_arranger[1,:]]),axis=0),self.elements[:,node_arranger[2,:]]),axis=0),
self.elements[:,node_arranger[3,:]]),axis=0),self.elements[:,node_arranger[4,:]]),axis=0),
self.elements[:,node_arranger[5,:]]),axis=0).astype(self.faces.dtype)
all_faces_in_faces = in2d(all_faces,self.faces[:,:4],consider_sort=True)
all_faces_in_faces = np.where(all_faces_in_faces==True)[0]
boundary_face_to_element = np.zeros((all_faces_in_faces.shape[0],2),dtype=np.int64)
boundary_face_to_element[:,0] = all_faces_in_faces % self.elements.shape[0]
boundary_face_to_element[:,1] = all_faces_in_faces // self.elements.shape[0]
# SO FAR WE HAVE COMPUTED THE ELEMENTS THAT CONTAIN FACES, HOWEVER
# NOTE THAT WE STILL HAVE NOT COMPUTED A MAPPING BETWEEN ELEMENTS AND
# FACES. WE ONLY KNOW WHICH ELEMENTS CONTAIN FACES FROM in2d.
# WE NEED TO FIND THIS MAPPING NOW
# WE NEED TO DO THIS DUMMY RECONSTRUCTION OF FACES BASED ON ELEMENTS
faces = self.elements[boundary_face_to_element[:,0][:,None],
node_arranger[boundary_face_to_element[:,1],:]].astype(self.faces.dtype)
# CHECK FOR THIS CONDITION AS ARRANGEMENT IS NO LONGER MAINTAINED
assert np.sum(faces[:,:4].astype(np.int64) - self.faces[:,:4].astype(np.int64)) == 0
# NOW GET THE ROW MAPPING BETWEEN OLD FACES AND NEW FACES
from Florence.Tensor import shuffle_along_axis
row_mapper = shuffle_along_axis(faces[:,:4],self.faces[:,:4],consider_sort=True)
# UPDATE THE MAP
boundary_face_to_element[:,:] = boundary_face_to_element[row_mapper,:]
self.boundary_face_to_element = boundary_face_to_element
return self.boundary_face_to_element
def GetElementsFaceNumberingHex(self):
"""Finds which faces belong to which elements and which faces of the elements
they are e.g. 0, 1, 2 or 3.
output:
face_elements: [2D array] nfaces x 2 array containing elements which have face
on the boundary with their flags
Note that this method also sets the self.face_to_element to face_elements,
so the return value is not strictly necessary
"""
if isinstance(self.face_to_element,np.ndarray):
if self.face_to_element.shape[0] > 1:
return self.face_to_element
assert self.elements is not None
# GET ALL FACES FROM ELEMENT CONNECTIVITY
if self.all_faces is None:
self.GetFacesHex()
C = self.InferPolynomialDegree() - 1
node_arranger = NodeArrangementHex(C)[0]
all_faces = np.concatenate((np.concatenate((
np.concatenate((np.concatenate((np.concatenate((self.elements[:,node_arranger[0,:]],
self.elements[:,node_arranger[1,:]]),axis=0),self.elements[:,node_arranger[2,:]]),axis=0),
self.elements[:,node_arranger[3,:]]),axis=0),self.elements[:,node_arranger[4,:]]),axis=0),
self.elements[:,node_arranger[5,:]]),axis=0).astype(self.all_faces.dtype)
_,idx = unique2d(all_faces,consider_sort=True,order=False, return_index=True)
face_elements = np.zeros((self.all_faces.shape[0],2),dtype=np.int64)
face_elements[:,0] = idx % self.elements.shape[0]
face_elements[:,1] = idx // self.elements.shape[0]
self.face_to_element = face_elements
return self.face_to_element
def ArrangeFacesHex(self):
"""Arranges all the faces of hexahedral elements
with quadrilateral type node ordering """
if self.all_faces is None:
self.all_faces = self.GetFacesHex()
if self.face_to_element is None:
self.GetElementsFaceNumberingHex()
# DETERMINE DEGREE
p = self.InferPolynomialDegree()
node_arranger = NodeArrangementHex(p-1)[0]
self.all_faces = self.elements[self.face_to_element[:,0][:,None],node_arranger[self.face_to_element[:,1],:]]
def GetNodeCommonality(self):
"""Finds the elements sharing a node.
The return values are linked lists [list of numpy of arrays].
Each numpy array within the list gives the elements that contain a given node.
As a result the size of the linked list is nnode
outputs:
els: [list of numpy arrays] element numbers containing nodes
pos: [list of numpy arrays] elemental positions of the nodes
res_flat: [list of numpy arrays] position of nodes in the
flattened element connectivity.
"""
self.__do_essential_memebers_exist__()
elements = self.elements.ravel()
idx_sort = np.argsort(elements)
sorted_elements = elements[idx_sort]
vals, idx_start = np.unique(sorted_elements, return_index=True)
# Sets of indices
flat_pos = | np.split(idx_sort, idx_start[1:]) | numpy.split |
"""
@author: <NAME>
"""
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import scipy.io
from scipy.interpolate import griddata
from mpl_toolkits.mplot3d import Axes3D
from pyDOE import lhs
import time
from plotting import newfig, savefig
import matplotlib.gridspec as gridspec
from mpl_toolkits.axes_grid1 import make_axes_locatable
###############################################################################
############################## Helper Functions ###############################
###############################################################################
def initialize_NN(layers):
weights = []
biases = []
num_layers = len(layers)
for l in range(0,num_layers-1):
W = xavier_init(size=[layers[l], layers[l+1]])
b = tf.Variable(tf.zeros([1,layers[l+1]], dtype=tf.float32), dtype=tf.float32)
weights.append(W)
biases.append(b)
return weights, biases
def xavier_init(size):
in_dim = size[0]
out_dim = size[1]
xavier_stddev = np.sqrt(2/(in_dim + out_dim))
return tf.Variable(tf.truncated_normal([in_dim, out_dim], stddev=xavier_stddev, dtype=tf.float32), dtype=tf.float32)
def neural_net(X, weights, biases):
num_layers = len(weights) + 1
H = X
for l in range(0,num_layers-2):
W = weights[l]
b = biases[l]
H = tf.sin(tf.add(tf.matmul(H, W), b))
W = weights[-1]
b = biases[-1]
Y = tf.add(tf.matmul(H, W), b)
return Y
###############################################################################
################################ DeepHPM Class ################################
###############################################################################
class DeepHPM:
def __init__(self, t, x, u,
x0, u0, tb, X_f,
u_layers, pde_layers,
layers,
lb_idn, ub_idn,
lb_sol, ub_sol):
# Domain Boundary
self.lb_idn = lb_idn
self.ub_idn = ub_idn
self.lb_sol = lb_sol
self.ub_sol = ub_sol
# Init for Identification
self.idn_init(t, x, u, u_layers, pde_layers)
# Init for Solution
self.sol_init(x0, u0, tb, X_f, layers)
# tf session
self.sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True,
log_device_placement=True))
init = tf.global_variables_initializer()
self.sess.run(init)
###########################################################################
############################# Identifier ##################################
###########################################################################
def idn_init(self, t, x, u, u_layers, pde_layers):
# Training Data for Identification
self.t = t
self.x = x
self.u = u
# Layers for Identification
self.u_layers = u_layers
self.pde_layers = pde_layers
# Initialize NNs for Identification
self.u_weights, self.u_biases = initialize_NN(u_layers)
self.pde_weights, self.pde_biases = initialize_NN(pde_layers)
# tf placeholders for Identification
self.t_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.x_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.u_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.terms_tf = tf.placeholder(tf.float32, shape=[None, pde_layers[0]])
# tf graphs for Identification
self.idn_u_pred = self.idn_net_u(self.t_tf, self.x_tf)
self.pde_pred = self.net_pde(self.terms_tf)
self.idn_f_pred = self.idn_net_f(self.t_tf, self.x_tf)
# loss for Identification
self.idn_u_loss = tf.reduce_sum(tf.square(self.idn_u_pred - self.u_tf))
self.idn_f_loss = tf.reduce_sum(tf.square(self.idn_f_pred))
# Optimizer for Identification
self.idn_u_optimizer = tf.contrib.opt.ScipyOptimizerInterface(self.idn_u_loss,
var_list = self.u_weights + self.u_biases,
method = 'L-BFGS-B',
options = {'maxiter': 50000,
'maxfun': 50000,
'maxcor': 50,
'maxls': 50,
'ftol': 1.0*np.finfo(float).eps})
self.idn_f_optimizer = tf.contrib.opt.ScipyOptimizerInterface(self.idn_f_loss,
var_list = self.pde_weights + self.pde_biases,
method = 'L-BFGS-B',
options = {'maxiter': 50000,
'maxfun': 50000,
'maxcor': 50,
'maxls': 50,
'ftol': 1.0*np.finfo(float).eps})
self.idn_u_optimizer_Adam = tf.train.AdamOptimizer()
self.idn_u_train_op_Adam = self.idn_u_optimizer_Adam.minimize(self.idn_u_loss,
var_list = self.u_weights + self.u_biases)
self.idn_f_optimizer_Adam = tf.train.AdamOptimizer()
self.idn_f_train_op_Adam = self.idn_f_optimizer_Adam.minimize(self.idn_f_loss,
var_list = self.pde_weights + self.pde_biases)
def idn_net_u(self, t, x):
X = tf.concat([t,x],1)
H = 2.0*(X - self.lb_idn)/(self.ub_idn - self.lb_idn) - 1.0
u = neural_net(H, self.u_weights, self.u_biases)
return u
def net_pde(self, terms):
pde = neural_net(terms, self.pde_weights, self.pde_biases)
return pde
def idn_net_f(self, t, x):
u = self.idn_net_u(t, x)
u_t = tf.gradients(u, t)[0]
u_x = tf.gradients(u, x)[0]
u_xx = tf.gradients(u_x, x)[0]
terms = tf.concat([u,u_x,u_xx],1)
f = u_t - self.net_pde(terms)
return f
def idn_u_train(self, N_iter):
tf_dict = {self.t_tf: self.t, self.x_tf: self.x, self.u_tf: self.u}
start_time = time.time()
for it in range(N_iter):
self.sess.run(self.idn_u_train_op_Adam, tf_dict)
# Print
if it % 10 == 0:
elapsed = time.time() - start_time
loss_value = self.sess.run(self.idn_u_loss, tf_dict)
print('It: %d, Loss: %.3e, Time: %.2f' %
(it, loss_value, elapsed))
start_time = time.time()
self.idn_u_optimizer.minimize(self.sess,
feed_dict = tf_dict,
fetches = [self.idn_u_loss],
loss_callback = self.callback)
def idn_f_train(self, N_iter):
tf_dict = {self.t_tf: self.t, self.x_tf: self.x}
start_time = time.time()
for it in range(N_iter):
self.sess.run(self.idn_f_train_op_Adam, tf_dict)
# Print
if it % 10 == 0:
elapsed = time.time() - start_time
loss_value = self.sess.run(self.idn_f_loss, tf_dict)
print('It: %d, Loss: %.3e, Time: %.2f' %
(it, loss_value, elapsed))
start_time = time.time()
self.idn_f_optimizer.minimize(self.sess,
feed_dict = tf_dict,
fetches = [self.idn_f_loss],
loss_callback = self.callback)
def idn_predict(self, t_star, x_star):
tf_dict = {self.t_tf: t_star, self.x_tf: x_star}
u_star = self.sess.run(self.idn_u_pred, tf_dict)
f_star = self.sess.run(self.idn_f_pred, tf_dict)
return u_star, f_star
def predict_pde(self, terms_star):
tf_dict = {self.terms_tf: terms_star}
pde_star = self.sess.run(self.pde_pred, tf_dict)
return pde_star
###########################################################################
############################### Solver ####################################
###########################################################################
def sol_init(self, x0, u0, tb, X_f, layers):
# Training Data for Solution
X0 = np.concatenate((0*x0, x0), 1) # (0, x0)
X_lb = np.concatenate((tb, 0*tb + self.lb_sol[1]), 1) # (tb, lb[1])
X_ub = np.concatenate((tb, 0*tb + self.ub_sol[1]), 1) # (tb, ub[1])
self.X_f = X_f # Collocation Points
self.t0 = X0[:,0:1] # Initial Data (time)
self.x0 = X0[:,1:2] # Initial Data (space)
self.t_lb = X_lb[:,0:1] # Boundary Data (time) -- lower boundary
self.x_lb = X_lb[:,1:2] # Boundary Data (space) -- lower boundary
self.t_ub = X_ub[:,0:1] # Boundary Data (time) -- upper boundary
self.x_ub = X_ub[:,1:2] # Boundary Data (space) -- upper boundary
self.t_f = X_f[:,0:1] # Collocation Points (time)
self.x_f = X_f[:,1:2] # Collocation Points (space)
self.u0 = u0 # Boundary Data
# Layers for Solution
self.layers = layers
# Initialize NNs for Solution
self.weights, self.biases = initialize_NN(layers)
# tf placeholders for Solution
self.t0_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.x0_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.u0_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.t_lb_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.x_lb_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.t_ub_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.x_ub_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.t_f_tf = tf.placeholder(tf.float32, shape=[None, 1])
self.x_f_tf = tf.placeholder(tf.float32, shape=[None, 1])
# tf graphs for Solution
self.u0_pred, _ = self.sol_net_u(self.t0_tf, self.x0_tf)
self.u_lb_pred, self.u_x_lb_pred = self.sol_net_u(self.t_lb_tf, self.x_lb_tf)
self.u_ub_pred, self.u_x_ub_pred = self.sol_net_u(self.t_ub_tf, self.x_ub_tf)
self.sol_f_pred = self.sol_net_f(self.t_f_tf, self.x_f_tf)
# loss for Solution
self.sol_loss = tf.reduce_sum(tf.square(self.u0_tf - self.u0_pred)) + \
tf.reduce_sum(tf.square(self.u_lb_pred - self.u_ub_pred)) + \
tf.reduce_sum(tf.square(self.u_x_lb_pred - self.u_x_ub_pred)) + \
tf.reduce_sum(tf.square(self.sol_f_pred))
# Optimizer for Solution
self.sol_optimizer = tf.contrib.opt.ScipyOptimizerInterface(self.sol_loss,
var_list = self.weights + self.biases,
method = 'L-BFGS-B',
options = {'maxiter': 50000,
'maxfun': 50000,
'maxcor': 50,
'maxls': 50,
'ftol': 1.0*np.finfo(float).eps})
self.sol_optimizer_Adam = tf.train.AdamOptimizer()
self.sol_train_op_Adam = self.sol_optimizer_Adam.minimize(self.sol_loss,
var_list = self.weights + self.biases)
def sol_net_u(self, t, x):
X = tf.concat([t,x],1)
H = 2.0*(X - self.lb_sol)/(self.ub_sol - self.lb_sol) - 1.0
u = neural_net(H, self.weights, self.biases)
u_x = tf.gradients(u, x)[0]
return u, u_x
def sol_net_f(self, t, x):
u, _ = self.sol_net_u(t,x)
u_t = tf.gradients(u, t)[0]
u_x = tf.gradients(u, x)[0]
u_xx = tf.gradients(u_x, x)[0]
terms = tf.concat([u,u_x,u_xx],1)
f = u_t - self.net_pde(terms)
return f
def callback(self, loss):
print('Loss: %e' % (loss))
def sol_train(self, N_iter):
tf_dict = {self.t0_tf: self.t0, self.x0_tf: self.x0,
self.u0_tf: self.u0,
self.t_lb_tf: self.t_lb, self.x_lb_tf: self.x_lb,
self.t_ub_tf: self.t_ub, self.x_ub_tf: self.x_ub,
self.t_f_tf: self.t_f, self.x_f_tf: self.x_f}
start_time = time.time()
for it in range(N_iter):
self.sess.run(self.sol_train_op_Adam, tf_dict)
# Print
if it % 10 == 0:
elapsed = time.time() - start_time
loss_value = self.sess.run(self.sol_loss, tf_dict)
print('It: %d, Loss: %.3e, Time: %.2f' %
(it, loss_value, elapsed))
start_time = time.time()
self.sol_optimizer.minimize(self.sess,
feed_dict = tf_dict,
fetches = [self.sol_loss],
loss_callback = self.callback)
def sol_predict(self, t_star, x_star):
u_star = self.sess.run(self.u0_pred, {self.t0_tf: t_star, self.x0_tf: x_star})
f_star = self.sess.run(self.sol_f_pred, {self.t_f_tf: t_star, self.x_f_tf: x_star})
return u_star, f_star
###############################################################################
################################ Main Function ################################
###############################################################################
if __name__ == "__main__":
# Doman bounds
lb_idn = np.array([0.0, -8.0])
ub_idn = np.array([10.0, 8.0])
lb_sol = np.array([0.0, -8.0])
ub_sol = np.array([10.0, 8.0])
### Load Data ###
data_idn = scipy.io.loadmat('../Data/burgers_sine.mat')
t_idn = data_idn['t'].flatten()[:,None]
x_idn = data_idn['x'].flatten()[:,None]
Exact_idn = np.real(data_idn['usol'])
T_idn, X_idn = np.meshgrid(t_idn,x_idn)
keep = 2/3
index = int(keep*t_idn.shape[0])
T_idn = T_idn[:,0:index]
X_idn = X_idn[:,0:index]
Exact_idn = Exact_idn[:,0:index]
t_idn_star = T_idn.flatten()[:,None]
x_idn_star = X_idn.flatten()[:,None]
X_idn_star = np.hstack((t_idn_star, x_idn_star))
u_idn_star = Exact_idn.flatten()[:,None]
#
data_sol = scipy.io.loadmat('../Data/burgers_sine.mat')
t_sol = data_sol['t'].flatten()[:,None]
x_sol = data_sol['x'].flatten()[:,None]
Exact_sol = np.real(data_sol['usol'])
T_sol, X_sol = np.meshgrid(t_sol,x_sol)
t_sol_star = T_sol.flatten()[:,None]
x_sol_star = X_sol.flatten()[:,None]
X_sol_star = np.hstack((t_sol_star, x_sol_star))
u_sol_star = Exact_sol.flatten()[:,None]
### Training Data ###
# For identification
N_train = 10000
idx = | np.random.choice(t_idn_star.shape[0], N_train, replace=False) | numpy.random.choice |
#!/usr/bin/env python
# Copyright 2018 Division of Medical Image Computing, German Cancer Research Center (DKFZ).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
import sys
import os
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
import numpy as np
from default_configs import DefaultConfigs
class configs(DefaultConfigs):
def __init__(self, server_env=None):
#########################
# Preprocessing #
#########################
self.root_dir = '/path/to/raw/data'
self.raw_data_dir = '{}/data_nrrd'.format(self.root_dir)
self.pp_dir = '{}/pp_norm'.format(self.root_dir)
self.target_spacing = (0.7, 0.7, 1.25)
#########################
# I/O #
#########################
# one out of [2, 3]. dimension the model operates in.
self.dim = 3
# one out of ['mrcnn', 'retina_net', 'retina_unet', 'detection_unet', 'ufrcnn', 'detection_unet'].
self.model = 'mrcnn'
DefaultConfigs.__init__(self, self.model, server_env, self.dim)
# int [0 < dataset_size]. select n patients from dataset for prototyping. If None, all data is used.
self.select_prototype_subset = 100
# path to preprocessed data.
self.pp_name = 'lidc_mdt'
self.input_df_name = 'info_df.pickle'
self.pp_data_path = '/media/gregor/HDD2TB/data/lidc/{}'.format(self.pp_name)
self.pp_test_data_path = self.pp_data_path #change if test_data in separate folder.
# settings for deployment in cloud.
if server_env:
# path to preprocessed data.
self.pp_name = 'lidc_mdt_npz'
self.crop_name = 'pp_fg_slices_packed'
self.pp_data_path = '/datasets/datasets_ramien/lidc_exp/data/{}'.format(self.pp_name)
self.pp_test_data_path = self.pp_data_path
self.select_prototype_subset = None
#########################
# Data Loader #
#########################
# select modalities from preprocessed data
self.channels = [0]
self.n_channels = len(self.channels)
# patch_size to be used for training. pre_crop_size is the patch_size before data augmentation.
self.pre_crop_size_2D = [300, 300]
self.patch_size_2D = [288, 288]
self.pre_crop_size_3D = [156, 156, 96]
self.patch_size_3D = [128, 128, 64]
self.patch_size = self.patch_size_2D if self.dim == 2 else self.patch_size_3D
self.pre_crop_size = self.pre_crop_size_2D if self.dim == 2 else self.pre_crop_size_3D
# ratio of free sampled batch elements before class balancing is triggered
# (>0 to include "empty"/background patches.)
self.batch_sample_slack = 0.2
# set 2D network to operate in 3D images.
self.merge_2D_to_3D_preds = True
# feed +/- n neighbouring slices into channel dimension. set to None for no context.
self.n_3D_context = None
if self.n_3D_context is not None and self.dim == 2:
self.n_channels *= (self.n_3D_context * 2 + 1)
#########################
# Architecture #
#########################
self.start_filts = 48 if self.dim == 2 else 18
self.end_filts = self.start_filts * 4 if self.dim == 2 else self.start_filts * 2
self.res_architecture = 'resnet50' # 'resnet101' , 'resnet50'
self.norm = None # one of None, 'instance_norm', 'batch_norm'
self.weight_decay = 0
# one of 'xavier_uniform', 'xavier_normal', or 'kaiming_normal', None (=default = 'kaiming_uniform')
self.weight_init = None
#########################
# Schedule / Selection #
#########################
self.num_epochs = 100
self.num_train_batches = 200 if self.dim == 2 else 200
self.batch_size = 20 if self.dim == 2 else 8
self.do_validation = True
# decide whether to validate on entire patient volumes (like testing) or sampled patches (like training)
# the former is morge accurate, while the latter is faster (depending on volume size)
self.val_mode = 'val_sampling' # one of 'val_sampling' , 'val_patient'
if self.val_mode == 'val_patient':
self.max_val_patients = 50 # if 'None' iterates over entire val_set once.
if self.val_mode == 'val_sampling':
self.num_val_batches = 50
#########################
# Testing / Plotting #
#########################
# set the top-n-epochs to be saved for temporal averaging in testing.
self.save_n_models = 5
self.test_n_epochs = 5
# set a minimum epoch number for saving in case of instabilities in the first phase of training.
self.min_save_thresh = 0 if self.dim == 2 else 0
self.report_score_level = ['patient', 'rois'] # choose list from 'patient', 'rois'
self.class_dict = {1: 'benign', 2: 'malignant'} # 0 is background.
self.patient_class_of_interest = 2 # patient metrics are only plotted for one class.
self.ap_match_ious = [0.1] # list of ious to be evaluated for ap-scoring.
self.model_selection_criteria = ['malignant_ap', 'benign_ap'] # criteria to average over for saving epochs.
self.min_det_thresh = 0.1 # minimum confidence value to select predictions for evaluation.
# threshold for clustering predictions together (wcs = weighted cluster scoring).
# needs to be >= the expected overlap of predictions coming from one model (typically NMS threshold).
# if too high, preds of the same object are separate clusters.
self.wcs_iou = 1e-5
self.plot_prediction_histograms = True
self.plot_stat_curves = False
#########################
# Data Augmentation #
#########################
self.da_kwargs={
'do_elastic_deform': True,
'alpha':(0., 1500.),
'sigma':(30., 50.),
'do_rotation':True,
'angle_x': (0., 2 * np.pi),
'angle_y': (0., 0),
'angle_z': (0., 0),
'do_scale': True,
'scale':(0.8, 1.1),
'random_crop':False,
'rand_crop_dist': (self.patch_size[0] / 2. - 3, self.patch_size[1] / 2. - 3),
'border_mode_data': 'constant',
'border_cval_data': 0,
'order_data': 1
}
if self.dim == 3:
self.da_kwargs['do_elastic_deform'] = False
self.da_kwargs['angle_x'] = (0, 0.0)
self.da_kwargs['angle_y'] = (0, 0.0) #must be 0!!
self.da_kwargs['angle_z'] = (0., 2 * np.pi)
#########################
# Add model specifics #
#########################
{'detection_unet': self.add_det_unet_configs,
'mrcnn': self.add_mrcnn_configs,
'ufrcnn': self.add_mrcnn_configs,
'retina_net': self.add_mrcnn_configs,
'retina_unet': self.add_mrcnn_configs,
}[self.model]()
def add_det_unet_configs(self):
self.learning_rate = [1e-4] * self.num_epochs
# aggregation from pixel perdiction to object scores (connected component). One of ['max', 'median']
self.aggregation_operation = 'max'
# max number of roi candidates to identify per batch element and class.
self.n_roi_candidates = 10 if self.dim == 2 else 30
# loss mode: either weighted cross entropy ('wce'), batch-wise dice loss ('dice), or the sum of both ('dice_wce')
self.seg_loss_mode = 'dice_wce'
# if <1, false positive predictions in foreground are penalized less.
self.fp_dice_weight = 1 if self.dim == 2 else 1
self.wce_weights = [1, 1, 1]
self.detection_min_confidence = self.min_det_thresh
# if 'True', loss distinguishes all classes, else only foreground vs. background (class agnostic).
self.class_specific_seg_flag = True
self.num_seg_classes = 3 if self.class_specific_seg_flag else 2
self.head_classes = self.num_seg_classes
def add_mrcnn_configs(self):
# learning rate is a list with one entry per epoch.
self.learning_rate = [1e-4] * self.num_epochs
# disable the re-sampling of mask proposals to original size for speed-up.
# since evaluation is detection-driven (box-matching) and not instance segmentation-driven (iou-matching),
# mask-outputs are optional.
self.return_masks_in_val = True
self.return_masks_in_test = False
# set number of proposal boxes to plot after each epoch.
self.n_plot_rpn_props = 5 if self.dim == 2 else 30
# number of classes for head networks: n_foreground_classes + 1 (background)
self.head_classes = 3
# seg_classes hier refers to the first stage classifier (RPN)
self.num_seg_classes = 2 # foreground vs. background
# feature map strides per pyramid level are inferred from architecture.
self.backbone_strides = {'xy': [4, 8, 16, 32], 'z': [1, 2, 4, 8]}
# anchor scales are chosen according to expected object sizes in data set. Default uses only one anchor scale
# per pyramid level. (outer list are pyramid levels (corresponding to BACKBONE_STRIDES), inner list are scales per level.)
self.rpn_anchor_scales = {'xy': [[8], [16], [32], [64]], 'z': [[2], [4], [8], [16]]}
# choose which pyramid levels to extract features from: P2: 0, P3: 1, P4: 2, P5: 3.
self.pyramid_levels = [0, 1, 2, 3]
# number of feature maps in rpn. typically lowered in 3D to save gpu-memory.
self.n_rpn_features = 512 if self.dim == 2 else 128
# anchor ratios and strides per position in feature maps.
self.rpn_anchor_ratios = [0.5, 1, 2]
self.rpn_anchor_stride = 1
# Threshold for first stage (RPN) non-maximum suppression (NMS): LOWER == HARDER SELECTION
self.rpn_nms_threshold = 0.7 if self.dim == 2 else 0.7
# loss sampling settings.
self.rpn_train_anchors_per_image = 6 #per batch element
self.train_rois_per_image = 6 #per batch element
self.roi_positive_ratio = 0.5
self.anchor_matching_iou = 0.7
# factor of top-k candidates to draw from per negative sample (stochastic-hard-example-mining).
# poolsize to draw top-k candidates from will be shem_poolsize * n_negative_samples.
self.shem_poolsize = 10
self.pool_size = (7, 7) if self.dim == 2 else (7, 7, 3)
self.mask_pool_size = (14, 14) if self.dim == 2 else (14, 14, 5)
self.mask_shape = (28, 28) if self.dim == 2 else (28, 28, 10)
self.rpn_bbox_std_dev = np.array([0.1, 0.1, 0.1, 0.2, 0.2, 0.2])
self.bbox_std_dev = | np.array([0.1, 0.1, 0.1, 0.2, 0.2, 0.2]) | numpy.array |
# coding = utf-8
import numpy as np
from feature_extractor import log_power_spectrum_extractor
from matplotlib import pylab
import matplotlib.pyplot as plt
from scikits.talkbox import lpc
from scipy.signal import lfilter, lfilter_zi, lfiltic
from scipy.io import wavfile
def freq2bark(f):
return 7.*np.log(f/650.+np.sqrt(np.power(1.+(f/650.), 2.)))
def bark2freq(b):
return 650.*np.sinh(b/7.)
def get_fft_bark_mat(sr, fft_len, barks, min_frq=20, max_frq=None):
if max_frq is None:
max_frq = sr // 2
fft_frqs = np.arange(0, fft_len//2+1) / (1.*fft_len) * sr
min_bark = freq2bark(min_frq)
max_bark = freq2bark(max_frq)
bark_bins = bark2freq(min_bark + | np.arange(0, barks+2) | numpy.arange |
"""Makes flattened views of volumetric data on the cortical surface.
"""
from six import string_types
from functools import reduce
import os
import glob
import numpy as np
import string
from .. import utils
from .. import dataset
from ..database import db
from ..options import config
def make_flatmap_image(braindata, height=1024, recache=False, **kwargs):
"""Generate flatmap image from volumetric brain data
This
Parameters
----------
braindata : one of: {cortex.Volume, cortex.Vertex, cortex.Dataview)
Object containing containing data to be plotted, subject (surface identifier),
and transform.
height : scalar
Height of image. None defaults to height of images already present in figure.
recache : boolean
Whether or not to recache intermediate files. Takes longer to plot this way, potentially
resolves some errors. Useful if you've made changes to the alignment.
kwargs : idk
idk
Returns
-------
image :
extents :
"""
mask, extents = get_flatmask(braindata.subject, height=height, recache=recache)
if not hasattr(braindata, "xfmname"):
pixmap = get_flatcache(braindata.subject,
None,
height=height,
recache=recache,
**kwargs)
if isinstance(braindata, dataset.Vertex2D):
data = braindata.raw.vertices
else:
data = braindata.vertices
else:
pixmap = get_flatcache(braindata.subject,
braindata.xfmname,
height=height,
recache=recache,
**kwargs)
if isinstance(braindata, dataset.Volume2D):
data = braindata.raw.volume
else:
data = braindata.volume
if data.shape[0] > 1:
raise ValueError("Input data was not the correct dimensionality - please provide 3D Volume or 2D Vertex data")
if data.dtype != np.uint8:
# Convert data to float to avoid image artifacts
data = data.astype(np.float)
if data.dtype == np.uint8:
img = np.zeros(mask.shape+(4,), dtype=np.uint8)
img[mask] = pixmap * data.reshape(-1, 4)
return img.transpose(1,0,2)[::-1], extents
else:
badmask = np.array(pixmap.sum(1) > 0).ravel()
img = (np.nan*np.ones(mask.shape)).astype(data.dtype)
mimg = (np.nan*np.ones(badmask.shape)).astype(data.dtype)
mimg[badmask] = (pixmap*data.ravel())[badmask].astype(mimg.dtype)
img[mask] = mimg
return img.T[::-1], extents
def get_flatmask(subject, height=1024, recache=False):
"""
Parameters
----------
subject : str
Name of subject in pycortex store
height : int
Height in pixels to generate the image
recache : bool
Recache the intermediate files? Can resolve some issues but is slower.
"""
cachedir = db.get_cache(subject)
cachefile = os.path.join(cachedir, "flatmask_{h}.npz".format(h=height))
if not os.path.exists(cachefile) or recache:
mask, extents = _make_flatmask(subject, height=height)
np.savez(cachefile, mask=mask, extents=extents)
else:
npz = np.load(cachefile)
mask, extents = npz['mask'], npz['extents']
npz.close()
return mask, extents
def get_flatcache(subject, xfmname, pixelwise=True, thick=32, sampler='nearest',
recache=False, height=1024, depth=0.5):
"""
Parameters
----------
subject : str
Subject name in pycortex db
xfmname : str
Name of transform for subject
pixelwise : bool
thick : int
sampler :
recache : bool
Recache intermediate files? Doing so is slower but can resolve some errors.
height : int
Height in pixels of image to generated
depth : float
Returns
-------
"""
cachedir = db.get_cache(subject)
cachefile = os.path.join(cachedir, "flatverts_{height}.npz").format(height=height)
if pixelwise and xfmname is not None:
cachefile = os.path.join(cachedir, "flatpixel_{xfmname}_{height}_{sampler}_{extra}.npz")
extra = "l%d"%thick if thick > 1 else "d%g"%depth
cachefile = cachefile.format(height=height, xfmname=xfmname, sampler=sampler, extra=extra)
if not os.path.exists(cachefile) or recache:
print("Generating a flatmap cache")
if pixelwise and xfmname is not None:
pixmap = _make_pixel_cache(subject, xfmname, height=height, sampler=sampler, thick=thick, depth=depth)
else:
pixmap = _make_vertex_cache(subject, height=height)
np.savez(cachefile, data=pixmap.data, indices=pixmap.indices, indptr=pixmap.indptr, shape=pixmap.shape)
else:
from scipy import sparse
npz = np.load(cachefile)
pixmap = sparse.csr_matrix((npz['data'], npz['indices'], npz['indptr']), shape=npz['shape'])
npz.close()
if not pixelwise and xfmname is not None:
from scipy import sparse
mapper = utils.get_mapper(subject, xfmname, sampler)
pixmap = pixmap * sparse.vstack(mapper.masks)
return pixmap
def _return_pixel_pairs(vert_pair_list, x_dict, y_dict):
"""Janky and probably unnecessary"""
pix_list = []
vert_pairs_valid = []
for (vert1, vert2) in vert_pair_list:
if vert1 in x_dict and vert2 in x_dict:
pix1 = np.array((x_dict[vert1], y_dict[vert1]))
pix2 = np.array((x_dict[vert2], y_dict[vert2]))
pix_list.append(np.array([pix1, pix2]))
vert_pairs_valid.append((vert1, vert2))
else:
#These are vertex pairs not represented in the flatmap. I have found them to belong to the middle brain are that is deleted while creating the flat map.
pass
return np.array(pix_list), np.array(vert_pairs_valid)
### --- Hidden helper functions --- ###
def _color2hex(color):
"""Convert arbitrary color input to hex string"""
from matplotlib import colors
cc = colors.ColorConverter()
rgba = cc.to_rgba(color)
hexcol = colors.rgb2hex(rgba)
return hexcol
def _convert_svg_kwargs(kwargs):
"""Convert matplotlib-like plotting property names/values to svg object property names/values"""
svg_style_key_mapping = dict(
linewidth='stroke-width',
lw='stroke-width',
linecolor='stroke',
lc='stroke',
#labelcolor='', # FIX ME
#labelsize='', # FIX ME
linealpha='stroke-opacity',
roifill='fill',
fillcolor='fill',
fillalpha='fill-opacity',
dashes='stroke-dasharray'
#dash_capstyle # ADD ME?
#dash_joinstyle # ADD ME?
)
svg_style_value_mapping = dict(
linewidth=lambda x: x,
lw=lambda x: x,
linecolor=lambda x: _color2hex(x),
lc=lambda x: _color2hex(x),
labelcolor=lambda x: _color2hex(x),
labelsize=lambda x: x,
linealpha=lambda x: x,
roifill=lambda x: _color2hex(x),
fillcolor=lambda x: _color2hex(x),
fillalpha=lambda x: x,
dashes=lambda x: '{}, {}'.format(*x),
#dash_capstyle # ADD ME?
#dash_joinstyle # ADD ME?
)
out = dict((svg_style_key_mapping[k], svg_style_value_mapping[k](v))
for k,v in kwargs.items() if v is not None)
return out
def _parse_defaults(section):
defaults = dict(config.items(section))
for k in defaults.keys():
# Convert numbers to floating point numbers
if defaults[k][0] in string.digits + '.':
if ',' in defaults[k]:
defaults[k] = [float(x) for x in defaults[k].split(',')]
else:
defaults[k] = float(defaults[k])
# Convert 'None' to None
if defaults[k] == 'None':
defaults[k] = None
# Special case formatting
if k=='stroke' or k=='fill':
defaults[k] = _color2hex(defaults[k])
elif k=='stroke-dasharray' and isinstance(defaults[k], (list,tuple)):
defaults[k] = '{}, {}'.format(*defaults[k])
return defaults
def _get_fig_and_ax(fig):
"""Get figure and current ax. Input can be either a figure or an ax."""
import matplotlib.pyplot as plt
if isinstance(fig, plt.Axes):
ax = fig
fig = ax.figure
elif isinstance(fig, plt.Figure):
ax = fig.gca()
else:
raise ValueError("fig should be a matplotlib Figure or Axes instance.")
return fig, ax
def _get_images(fig):
"""Get all images in a given matplotlib axis"""
from matplotlib.image import AxesImage
_, ax = _get_fig_and_ax(fig)
images = dict((x.get_label(), x) for x in ax.get_children() if isinstance(x, AxesImage))
return images
def _get_extents(fig):
"""Get extents of images current in a given matplotlib figure"""
images = _get_images(fig)
if 'data' not in images:
raise ValueError("You must specify `extents` argument if you have not yet plotted a data flatmap!")
extents = images['data'].get_extent()
return extents
def _get_height(fig):
"""Get height of images in currently in a given matplotlib figure"""
images = _get_images(fig)
if 'data_cutout' in images:
raise Exception("Can't add plots once cutout has been performed! Do cutouts last!")
if 'data' in images:
height = images['data'].get_array().shape[0]
else:
# No images, revert to default
height = 1024
return height
def _make_hatch_image(hatch_data, height, sampler='nearest', hatch_space=4, recache=False):
"""Make hatch image
Parameters
----------
hatch_data : cortex.Dataview
brain data with values ranging from 0-1, specifying where to show hatch marks (data value
will be mapped to alpha value of hatch marks)
height : scalar
height of image to display
sampler : string
pycortex sampler string, {'nearest', ...} (FILL ME IN ??)
hatch_space : scalar
space between hatch lines (in pixels)
recache : boolean
"""
dmap, _ = make_flatmap_image(hatch_data, height=height, sampler=sampler, recache=recache)
hx, hy = np.meshgrid(range(dmap.shape[1]), range(dmap.shape[0]))
hatchpat = (hx+hy)%(2*hatch_space) < 2
# Leila code that breaks:
#hatch_size = [0, 4, 4]
#hatchpat = (hx + hy + hatch_size[0])%(hatch_size[1] * hatch_space) < hatch_size[2]
hatchpat = np.logical_or(hatchpat, hatchpat[:,::-1]).astype(float)
hatchim = np.dstack([1-hatchpat]*3 + [hatchpat])
hatchim[:, : ,3] *= np.clip(dmap, 0, 1).astype(float)
return hatchim
def _make_flatmask(subject, height=1024):
from .. import polyutils
from PIL import Image, ImageDraw
pts, polys = db.get_surf(subject, "flat", merge=True, nudge=True)
left, right = polyutils.trace_poly(polyutils.boundary_edges(polys))
aspect = (height / (pts.max(0) - pts.min(0))[1])
lpts = (pts[left] - pts.min(0)) * aspect
rpts = (pts[right] - pts.min(0)) * aspect
im = Image.new('L', (int(aspect * (pts.max(0) - pts.min(0))[0]), height))
draw = ImageDraw.Draw(im)
draw.polygon(lpts[:,:2].ravel().tolist(), fill=255)
draw.polygon(rpts[:,:2].ravel().tolist(), fill=255)
extents = np.hstack([pts.min(0), pts.max(0)])[[0,3,1,4]]
return np.array(im).T > 0, extents
def _make_vertex_cache(subject, height=1024):
from scipy import sparse
from scipy.spatial import cKDTree
flat, polys = db.get_surf(subject, "flat", merge=True, nudge=True)
valid = np.unique(polys)
fmax, fmin = flat.max(0), flat.min(0)
size = fmax - fmin
aspect = size[0] / size[1]
width = int(aspect * height)
grid = np.mgrid[fmin[0]:fmax[0]:width*1j, fmin[1]:fmax[1]:height*1j].reshape(2,-1)
mask, extents = get_flatmask(subject, height=height)
assert mask.shape[0] == width and mask.shape[1] == height
kdt = cKDTree(flat[valid,:2])
dist, vert = kdt.query(grid.T[mask.ravel()])
dataij = (np.ones((len(vert),)), np.array([np.arange(len(vert)), valid[vert]]))
return sparse.csr_matrix(dataij, shape=(mask.sum(), len(flat)))
def _make_pixel_cache(subject, xfmname, height=1024, thick=32, depth=0.5, sampler='nearest'):
from scipy import sparse
from scipy.spatial import Delaunay
flat, polys = db.get_surf(subject, "flat", merge=True, nudge=True)
valid = np.unique(polys)
fmax, fmin = flat.max(0), flat.min(0)
size = fmax - fmin
aspect = size[0] / size[1]
width = int(aspect * height)
grid = np.mgrid[fmin[0]:fmax[0]:width*1j, fmin[1]:fmax[1]:height*1j].reshape(2,-1)
mask, extents = get_flatmask(subject, height=height)
assert mask.shape[0] == width and mask.shape[1] == height
# Get barycentric coordinates
dl = Delaunay(flat[valid,:2])
simps = dl.find_simplex(grid.T[mask.ravel()])
missing = simps == -1
tfms = dl.transform[simps]
l1, l2 = (tfms[:,:2].transpose(1,2,0) * (grid.T[mask.ravel()] - tfms[:,2]).T).sum(1)
l3 = 1 - l1 - l2
ll = np.vstack([l1, l2, l3])
ll[:,missing] = 0
from ..mapper import samplers
xfm = db.get_xfm(subject, xfmname, xfmtype='coord')
sampclass = getattr(samplers, sampler)
# Transform fiducial vertex locations to pixel locations using barycentric xfm
try:
pia, polys = db.get_surf(subject, "pia", merge=True, nudge=False)
wm, polys = db.get_surf(subject, "wm", merge=True, nudge=False)
piacoords = xfm((pia[valid][dl.vertices][simps] * ll[np.newaxis].T).sum(1))
wmcoords = xfm((wm[valid][dl.vertices][simps] * ll[np.newaxis].T).sum(1))
valid_p = np.array([np.all((0 <= piacoords), axis=1),
piacoords[:,0] < xfm.shape[2],
piacoords[:,1] < xfm.shape[1],
piacoords[:,2] < xfm.shape[0]])
valid_p = np.all(valid_p, axis=0)
valid_w = np.array([np.all((0 <= wmcoords), axis=1),
wmcoords[:,0] < xfm.shape[2],
wmcoords[:,1] < xfm.shape[1],
wmcoords[:,2] < xfm.shape[0]])
valid_w = np.all(valid_w, axis=0)
valid = np.logical_and(valid_p, valid_w)
vidx = | np.nonzero(valid) | numpy.nonzero |
#
# Copyright 2019 The FATE 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.
#
from collections import defaultdict
import math
from federatedml.util import LOGGER
from federatedml.model_base import Metric, MetricMeta
from federatedml.param import EvaluateParam
from federatedml.util import consts
from federatedml.model_base import ModelBase
from federatedml.evaluation.metric_interface import MetricInterface
import numpy as np
class Evaluation(ModelBase):
def __init__(self):
super().__init__()
self.model_param = EvaluateParam()
self.eval_results = defaultdict(list)
self.save_single_value_metric_list = [consts.AUC,
consts.EXPLAINED_VARIANCE,
consts.MEAN_ABSOLUTE_ERROR,
consts.MEAN_SQUARED_ERROR,
consts.MEAN_SQUARED_LOG_ERROR,
consts.MEDIAN_ABSOLUTE_ERROR,
consts.R2_SCORE,
consts.ROOT_MEAN_SQUARED_ERROR,
consts.JACCARD_SIMILARITY_SCORE,
consts.ADJUSTED_RAND_SCORE,
consts.FOWLKES_MALLOWS_SCORE,
consts.DAVIES_BOULDIN_INDEX
]
self.special_metric_list = [consts.PSI]
self.clustering_intra_metric_list = [consts.DAVIES_BOULDIN_INDEX, consts.DISTANCE_MEASURE]
self.metrics = None
self.round_num = 6
self.eval_type = None
# where to call metric computations
self.metric_interface: MetricInterface = None
self.psi_train_scores, self.psi_validate_scores = None, None
self.psi_train_labels, self.psi_validate_labels = None, None
# multi unfold setting
self.need_unfold_multi_result = False
# summaries
self.metric_summaries = {}
def _init_model(self, model):
self.model_param = model
self.eval_type = self.model_param.eval_type
self.pos_label = self.model_param.pos_label
self.need_unfold_multi_result = self.model_param.unfold_multi_result
self.metrics = model.metrics
self.metric_interface = MetricInterface(pos_label=self.pos_label, eval_type=self.eval_type, )
def _run_data(self, data_sets=None, stage=None):
if not self.need_run:
return
data = {}
for data_key in data_sets:
if data_sets[data_key].get("data", None):
data[data_key] = data_sets[data_key]["data"]
if stage == "fit":
self.data_output = self.fit(data)
else:
LOGGER.warning("Evaluation has not transform, return")
def split_data_with_type(self, data: list) -> dict:
split_result = defaultdict(list)
for value in data:
mode = value[1][-1]
split_result[mode].append(value)
return split_result
def _classification_and_regression_extract(self, data):
"""
extract labels and predict results from data in classification/regression type format
"""
labels = []
pred_scores = []
pred_labels = []
for d in data:
labels.append(d[1][0])
pred_labels.append(d[1][1])
pred_scores.append(d[1][2])
if self.eval_type == consts.BINARY or self.eval_type == consts.REGRESSION:
if self.pos_label and self.eval_type == consts.BINARY:
labels_arr = np.array(labels)
labels_arr[labels_arr == self.pos_label] = 1
labels_arr[labels_arr != self.pos_label] = 0
labels = list(labels_arr)
pred_results = pred_scores
else:
pred_results = pred_labels
return labels, pred_results
def _clustering_extract(self, data):
"""
extract data according to data format
"""
true_cluster_index, predicted_cluster_index = [], []
intra_cluster_data, inter_cluster_dist = {'avg_dist': [], 'max_radius': []}, []
run_intra_metrics = False # run intra metrics or outer metrics ?
if len(data[0][1]) == 3:
# [int int] -> [true_label, predicted label] -> outer metric
# [int np.array] - > [predicted label, distance] -> need no metric computation
if not (isinstance(data[0][1][0], int) and isinstance(data[0][1][1], int)):
return None, None, run_intra_metrics
if len(data[0][1]) == 5: # the input format is for intra metrics
run_intra_metrics = True
cluster_index_list = []
for d in data:
if run_intra_metrics:
cluster_index_list.append(d[0])
intra_cluster_data['avg_dist'].append(d[1][1])
intra_cluster_data['max_radius'].append(d[1][2])
if len(inter_cluster_dist) == 0:
inter_cluster_dist += d[1][3]
else:
true_cluster_index.append(d[1][0])
predicted_cluster_index.append(d[1][1])
# if cluster related data exists, sort by cluster index
if len(cluster_index_list) != 0:
to_sort = list(zip(cluster_index_list, intra_cluster_data['avg_dist'], intra_cluster_data['max_radius']))
sort_rs = sorted(to_sort, key=lambda x: x[0]) # cluster index
intra_cluster_data['avg_dist'] = [i[1] for i in sort_rs]
intra_cluster_data['max_radius'] = [i[2] for i in sort_rs]
return (true_cluster_index, predicted_cluster_index, run_intra_metrics) if not run_intra_metrics else \
(intra_cluster_data, inter_cluster_dist, run_intra_metrics)
def _evaluate_classification_and_regression_metrics(self, mode, data):
labels, pred_results = self._classification_and_regression_extract(data)
eval_result = defaultdict(list)
for eval_metric in self.metrics:
if eval_metric not in self.special_metric_list:
res = getattr(self.metric_interface, eval_metric)(labels, pred_results)
if res is not None:
try:
if math.isinf(res):
res = float(-9999999)
LOGGER.info("res is inf, set to {}".format(res))
except BaseException:
pass
eval_result[eval_metric].append(mode)
eval_result[eval_metric].append(res)
elif eval_metric == consts.PSI:
if mode == 'train':
self.psi_train_scores = pred_results
self.psi_train_labels = labels
elif mode == 'validate':
self.psi_validate_scores = pred_results
self.psi_validate_labels = labels
if self.psi_train_scores is not None and self.psi_validate_scores is not None:
res = self.metric_interface.psi(self.psi_train_scores, self.psi_validate_scores,
self.psi_train_labels, self.psi_validate_labels)
eval_result[eval_metric].append(mode)
eval_result[eval_metric].append(res)
# delete saved scores after computing a psi pair
self.psi_train_scores, self.psi_validate_scores = None, None
return eval_result
def _evaluate_clustering_metrics(self, mode, data):
eval_result = defaultdict(list)
rs0, rs1, run_outer_metric = self._clustering_extract(data)
if rs0 is None and rs1 is None: # skip evaluation computation if get this input format
LOGGER.debug('skip computing, this clustering format is not for metric computation')
return eval_result
if not run_outer_metric:
no_label = (np.array(rs0) is None).all()
if no_label:
LOGGER.debug('no label found in clustering result, skip metric computation')
return eval_result
for eval_metric in self.metrics:
# if input format and required metrics matches ? XNOR
if not ((not (eval_metric in self.clustering_intra_metric_list) and not run_outer_metric) +
((eval_metric in self.clustering_intra_metric_list) and run_outer_metric)):
LOGGER.warning('input data format does not match current clustering metric: {}'.format(eval_metric))
continue
LOGGER.debug('clustering_metrics is {}'.format(eval_metric))
if run_outer_metric:
if eval_metric == consts.DISTANCE_MEASURE:
res = getattr(self.metric_interface, eval_metric)(rs0['avg_dist'], rs1, rs0['max_radius'])
else:
res = getattr(self.metric_interface, eval_metric)(rs0['avg_dist'], rs1)
else:
res = getattr(self.metric_interface, eval_metric)(rs0, rs1)
eval_result[eval_metric].append(mode)
eval_result[eval_metric].append(res)
return eval_result
@staticmethod
def _check_clustering_input(data):
# one evaluation component is only available for one kmeans component in current version
input_num = len(data.items())
if input_num > 1:
raise ValueError('multiple input detected, '
'one evaluation component is only available '
'for one clustering(kmean) component in current version')
@staticmethod
def _unfold_multi_result(score_list):
"""
one-vs-rest transformation: multi classification result to several binary classification results
"""
binary_result = {}
for key, multi_result in score_list:
true_label = multi_result[0]
predicted_label = multi_result[1]
multi_score = multi_result[3]
data_type = multi_result[-1]
# to binary predict result format
for multi_label in multi_score:
bin_label = 1 if str(multi_label) == str(true_label) else 0
bin_predicted_label = 1 if str(multi_label) == str(predicted_label) else 0
bin_score = multi_score[multi_label]
neg_bin_score = 1 - bin_score
result_list = [bin_label, bin_predicted_label, bin_score, {1: bin_score, 0: neg_bin_score}, data_type]
if multi_label not in binary_result:
binary_result[multi_label] = []
binary_result[multi_label].append((key, result_list))
return binary_result
def evaluate_metrics(self, mode: str, data: list) -> dict:
eval_result = None
if self.eval_type != consts.CLUSTERING:
eval_result = self._evaluate_classification_and_regression_metrics(mode, data)
elif self.eval_type == consts.CLUSTERING:
LOGGER.debug('running clustering')
eval_result = self._evaluate_clustering_metrics(mode, data)
return eval_result
def obtain_data(self, data_list):
return data_list
def check_data(self, data):
if len(data) <= 0:
return
if self.eval_type == consts.CLUSTERING:
self._check_clustering_input(data)
else:
for key, eval_data in data.items():
if eval_data is None:
continue
sample = eval_data.take(1)[0]
# label, predict_type, predict_score, predict_detail, type
if not isinstance(sample[1].features, list) or len(sample[1].features) != 5:
raise ValueError('length of table header mismatch, expected length is 5, got:{},'
'please check the input of the Evaluation Module, result of '
'cross validation is not supported.'.format(sample))
def fit(self, data, return_result=False):
self.check_data(data)
LOGGER.debug(f'running eval, data: {data}')
self.eval_results.clear()
for (key, eval_data) in data.items():
if eval_data is None:
LOGGER.debug('data with {} is None, skip metric computation'.format(key))
continue
collected_data = list(eval_data.collect())
if len(collected_data) == 0:
continue
eval_data_local = []
for k, v in collected_data:
eval_data_local.append((k, v.features))
split_data_with_label = self.split_data_with_type(eval_data_local)
for mode, data in split_data_with_label.items():
eval_result = self.evaluate_metrics(mode, data)
self.eval_results[key].append(eval_result)
if self.need_unfold_multi_result and self.eval_type == consts.MULTY:
unfold_binary_eval_result = defaultdict(list)
# set work mode to binary evaluation
self.eval_type = consts.BINARY
self.metric_interface.eval_type = consts.ONE_VS_REST
back_up_metric = self.metrics
self.metrics = [consts.AUC, consts.KS]
for mode, data in split_data_with_label.items():
unfold_multi_data = self._unfold_multi_result(eval_data_local)
for multi_label, marginal_bin_result in unfold_multi_data.items():
eval_result = self.evaluate_metrics(mode, marginal_bin_result)
new_key = key + '_class_{}'.format(multi_label)
unfold_binary_eval_result[new_key].append(eval_result)
self.callback_ovr_metric_data(unfold_binary_eval_result)
# recover work mode
self.eval_type = consts.MULTY
self.metric_interface.eval_type = consts.MULTY
self.metrics = back_up_metric
return self.callback_metric_data(self.eval_results, return_single_val_metrics=return_result)
def __save_single_value(self, result, metric_name, metric_namespace, eval_name):
metric_type = 'EVALUATION_SUMMARY'
if eval_name in consts.ALL_CLUSTER_METRICS:
metric_type = 'CLUSTERING_EVALUATION_SUMMARY'
self.tracker.log_metric_data(metric_namespace, metric_name,
[Metric(eval_name, np.round(result, self.round_num))])
self.tracker.set_metric_meta(metric_namespace, metric_name,
MetricMeta(name=metric_name, metric_type=metric_type))
def __save_curve_data(self, x_axis_list, y_axis_list, metric_name, metric_namespace):
points = []
for i, value in enumerate(x_axis_list):
if isinstance(value, float):
value = np.round(value, self.round_num)
points.append((value, np.round(y_axis_list[i], self.round_num)))
points.sort(key=lambda x: x[0])
metric_points = [Metric(point[0], point[1]) for point in points]
self.tracker.log_metric_data(metric_namespace, metric_name, metric_points)
def __save_curve_meta(self, metric_name, metric_namespace, metric_type, unit_name=None, ordinate_name=None,
curve_name=None, best=None, pair_type=None, thresholds=None):
extra_metas = {}
metric_type = "_".join([metric_type, "EVALUATION"])
key_list = ["unit_name", "ordinate_name", "curve_name", "best", "pair_type", "thresholds"]
for key in key_list:
value = locals()[key]
if value:
if key == "thresholds":
value = np.round(value, self.round_num).tolist()
extra_metas[key] = value
self.tracker.set_metric_meta(metric_namespace, metric_name,
MetricMeta(name=metric_name, metric_type=metric_type, extra_metas=extra_metas))
@staticmethod
def __multi_class_label_padding(metrics, label_indices):
# in case some labels don't appear when running homo-multi-class algo
label_num = np.max(label_indices) + 1
index_result_mapping = dict(zip(label_indices, metrics))
new_metrics, new_label_indices = [], []
for i in range(label_num):
if i in index_result_mapping:
new_metrics.append(index_result_mapping[i])
else:
new_metrics.append(0.0)
new_label_indices.append(i)
return new_metrics, new_label_indices
@staticmethod
def __filt_override_unit_ordinate_coordinate(x_sets, y_sets):
max_y_dict = {}
for idx, x_value in enumerate(x_sets):
if x_value not in max_y_dict:
max_y_dict[x_value] = {"max_y": y_sets[idx], "idx": idx}
else:
max_y = max_y_dict[x_value]["max_y"]
if max_y < y_sets[idx]:
max_y_dict[x_value] = {"max_y": y_sets[idx], "idx": idx}
x = []
y = []
idx_list = []
for key, value in max_y_dict.items():
x.append(key)
y.append(value["max_y"])
idx_list.append(value["idx"])
return x, y, idx_list
def __process_single_value_data(self, metric, metric_res):
single_val_metric = None
if metric in self.save_single_value_metric_list or \
(metric == consts.ACCURACY and self.eval_type == consts.MULTY):
single_val_metric = metric_res[1]
elif metric == consts.KS:
best_ks, fpr, tpr, thresholds, cuts = metric_res[1]
single_val_metric = best_ks
elif metric in [consts.RECALL, consts.PRECISION] and self.eval_type == consts.MULTY:
pos_score = metric_res[1][0]
single_val_metric = float(np.array(pos_score).mean())
return single_val_metric
@staticmethod
def __filter_duplicate_roc_data_point(fpr, tpr, thresholds):
data_point_set = set()
new_fpr, new_tpr, new_threshold = [], [], []
for fpr_, tpr_, thres in zip(fpr, tpr, thresholds):
if (fpr_, tpr_, thres) not in data_point_set:
data_point_set.add((fpr_, tpr_, thres))
new_fpr.append(fpr_)
new_tpr.append(tpr_)
new_threshold.append(thres)
return new_fpr, new_tpr, new_threshold
def __save_roc_curve(self, data_name, metric_name, metric_namespace, metric_res):
fpr, tpr, thresholds, _ = metric_res
fpr, tpr, thresholds = self.__filter_duplicate_roc_data_point(fpr, tpr, thresholds)
# set roc edge value
fpr.append(1.0)
tpr.append(1.0)
thresholds.append(1.0)
self.__save_curve_data(fpr, tpr, metric_name, metric_namespace)
self.__save_curve_meta(metric_name=metric_name, metric_namespace=metric_namespace,
metric_type="ROC", unit_name="fpr", ordinate_name="tpr",
curve_name=data_name, thresholds=thresholds)
def __save_ks_curve(self, metric, metric_res, metric_name, metric_namespace, data_name):
best_ks, fpr, tpr, thresholds, cuts = metric_res[1]
for curve_name, curve_data in zip(["fpr", "tpr"], [fpr, tpr]):
metric_name_fpr = '_'.join([metric_name, curve_name])
curve_name_fpr = "_".join([data_name, curve_name])
self.__save_curve_data(cuts, curve_data, metric_name_fpr, metric_namespace)
self.__save_curve_meta(metric_name=metric_name_fpr, metric_namespace=metric_namespace,
metric_type=metric.upper(), unit_name="",
curve_name=curve_name_fpr, pair_type=data_name,
thresholds=thresholds)
def __save_lift_gain_curve(self, metric, metric_res, metric_name, metric_namespace, data_name):
score, cuts, thresholds = metric_res[1]
score = [float(s[1]) for s in score]
cuts = [float(c[1]) for c in cuts]
cuts, score, idx_list = self.__filt_override_unit_ordinate_coordinate(cuts, score)
thresholds = [thresholds[idx] for idx in idx_list]
score.append(1.0)
cuts.append(1.0)
thresholds.append(0.0)
self.__save_curve_data(cuts, score, metric_name, metric_namespace)
self.__save_curve_meta(metric_name=metric_name, metric_namespace=metric_namespace,
metric_type=metric.upper(), unit_name="",
curve_name=data_name, thresholds=thresholds)
def __save_accuracy_curve(self, metric, metric_res, metric_name, metric_namespace, data_name):
if self.eval_type == consts.MULTY:
return
score, cuts, thresholds = metric_res[1]
self.__save_curve_data(cuts, score, metric_name, metric_namespace)
self.__save_curve_meta(metric_name=metric_name, metric_namespace=metric_namespace,
metric_type=metric.upper(), unit_name="",
curve_name=data_name, thresholds=thresholds)
def __save_pr_curve(self, precision_and_recall, data_name):
precision_res = precision_and_recall[consts.PRECISION]
recall_res = precision_and_recall[consts.RECALL]
if precision_res[0] != recall_res[0]:
LOGGER.warning(
"precision mode:{} is not equal to recall mode:{}".format(precision_res[0],
recall_res[0]))
return
metric_namespace = precision_res[0]
metric_name_precision = '_'.join([data_name, "precision"])
metric_name_recall = '_'.join([data_name, "recall"])
pos_precision_score = precision_res[1][0]
precision_cuts = precision_res[1][1]
if len(precision_res[1]) >= 3:
precision_thresholds = precision_res[1][2]
else:
precision_thresholds = None
pos_recall_score = recall_res[1][0]
recall_cuts = recall_res[1][1]
if len(recall_res[1]) >= 3:
recall_thresholds = recall_res[1][2]
else:
recall_thresholds = None
precision_curve_name = data_name
recall_curve_name = data_name
if self.eval_type == consts.BINARY:
pos_precision_score = [score[1] for score in pos_precision_score]
pos_recall_score = [score[1] for score in pos_recall_score]
pos_recall_score, pos_precision_score, idx_list = self.__filt_override_unit_ordinate_coordinate(
pos_recall_score, pos_precision_score)
precision_cuts = [precision_cuts[idx] for idx in idx_list]
recall_cuts = [recall_cuts[idx] for idx in idx_list]
edge_idx = idx_list[-1]
if edge_idx == len(precision_thresholds) - 1:
idx_list = idx_list[:-1]
precision_thresholds = [precision_thresholds[idx] for idx in idx_list]
recall_thresholds = [recall_thresholds[idx] for idx in idx_list]
elif self.eval_type == consts.MULTY:
pos_recall_score, recall_cuts = self.__multi_class_label_padding(pos_recall_score, recall_cuts)
pos_precision_score, precision_cuts = self.__multi_class_label_padding(pos_precision_score, precision_cuts)
self.__save_curve_data(precision_cuts, pos_precision_score, metric_name_precision,
metric_namespace)
self.__save_curve_meta(metric_name_precision, metric_namespace,
"_".join([consts.PRECISION.upper(), self.eval_type.upper()]),
unit_name="", ordinate_name="Precision",
curve_name=precision_curve_name,
pair_type=data_name, thresholds=precision_thresholds)
self.__save_curve_data(recall_cuts, pos_recall_score, metric_name_recall,
metric_namespace)
self.__save_curve_meta(metric_name_recall, metric_namespace,
"_".join([consts.RECALL.upper(), self.eval_type.upper()]),
unit_name="", ordinate_name="Recall", curve_name=recall_curve_name,
pair_type=data_name, thresholds=recall_thresholds)
def __save_confusion_mat_table(self, metric, confusion_mat, thresholds, metric_name, metric_namespace):
extra_metas = {'tp': list(confusion_mat['tp']), 'tn': list(confusion_mat['tn']),
'fp': list(confusion_mat['fp']),
'fn': list(confusion_mat['fn']), 'thresholds': list(np.round(thresholds, self.round_num))}
self.tracker.set_metric_meta(metric_namespace, metric_name,
MetricMeta(name=metric_name, metric_type=metric.upper(), extra_metas=extra_metas))
def __save_f1_score_table(self, metric, f1_scores, thresholds, metric_name, metric_namespace):
extra_metas = {'f1_scores': list(np.round(f1_scores, self.round_num)),
'thresholds': list(np.round(thresholds, self.round_num))}
self.tracker.set_metric_meta(metric_namespace, metric_name,
MetricMeta(name=metric_name, metric_type=metric.upper(), extra_metas=extra_metas))
def __save_psi_table(self, metric, metric_res, metric_name, metric_namespace):
psi_scores, total_psi, expected_interval, expected_percentage, actual_interval, actual_percentage, \
train_pos_perc, validate_pos_perc, intervals = metric_res[1]
extra_metas = {'psi_scores': list( | np.round(psi_scores, self.round_num) | numpy.round |
"""Performance metrics for photo-z prediction."""
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib.colors import ListedColormap
import mpl_scatter_density
import numpy as np
import scipy
from scipy.special import softmax
from scipy.stats import gaussian_kde
params = {
"legend.fontsize": "x-large",
"axes.labelsize": "x-large",
"axes.titlesize": "x-large",
"xtick.labelsize": "x-large",
"ytick.labelsize": "x-large",
"figure.facecolor": "w",
"xtick.top": True,
"ytick.right": True,
"xtick.direction": "in",
"ytick.direction": "in",
}
plt.rcParams.update(params)
def bins_to_redshifts(ind_bin, z_min=None, num_class=None, dz=None, return_edges=False):
"""Convert bin labels into redshift bin edges or central values.
Args:
ind_bin (array): Index of redshift bins
z_min (float): Minimum of the redshift range
num_class (int): Number of redshift classes
dz (float): Width of the redshift bins
return_edges (bool): If True, return the bin edges, otherwise
return the bin centers. Default is False.
Returns:
array: edges or centers or redshift bins (see `return_edges`
arg)
"""
ind_bin = np.atleast_1d(ind_bin)
z_max = z_min + num_class * dz
edges = | np.arange(z_min, z_max + dz, dz) | numpy.arange |
# GPS P code construction
#
# Copyright 2014 <NAME>
import numpy as np
chip_rate = 10230000
code_length = chip_rate*86400*7
def x1a_shift(x):
return [x[11]^x[10]^x[7]^x[5]] + x[0:11]
def x1b_shift(x):
return [x[11]^x[10]^x[9]^x[8]^x[7]^x[4]^x[1]^x[0]] + x[0:11]
def x2a_shift(x):
return [x[11]^x[10]^x[9]^x[8]^x[7]^x[6]^x[4]^x[3]^x[2]^x[0]] + x[0:11]
def x2b_shift(x):
return [x[11]^x[8]^x[7]^x[3]^x[2]^x[1]] + x[0:11]
def make_12bit(reg_shift,reg_initial,n):
x = reg_initial
s = np.zeros(n)
for i in range(n):
s[i] = x[11]
x = reg_shift(x)
return s
x1a = make_12bit(x1a_shift,[0,0,0,1,0,0,1,0,0,1,0,0],4092)
x1b = make_12bit(x1b_shift,[0,0,1,0,1,0,1,0,1,0,1,0],4093)
x2a = make_12bit(x2a_shift,[1,0,1,0,0,1,0,0,1,0,0,1],4092)
x2b = make_12bit(x2b_shift,[0,0,1,0,1,0,1,0,1,0,1,0],4093)
def x1(prn,start,len):
idx = start + np.arange(len)
idx = idx % 15345000
p_x1a = x1a[idx % 4092]
hold = idx>=(15345000-343)
idx[hold] = 4092
p_x1b = x1b[idx % 4093]
return np.logical_xor(p_x1a,p_x1b)
def x2(prn,start,len):
idx = start + np.arange(len)
idx = idx % 15345037
idx_a = idx.copy()
hold = idx_a>=(15345037-37)
idx_a[hold] = 4091
p_x2a = x2a[idx_a % 4092]
idx_b = idx.copy()
hold = idx_b>=(15345037-37-343)
idx_b[hold] = 4092
p_x2b = x2b[idx_b % 4093]
return np.logical_xor(p_x2a,p_x2b)
def last_x2(prn,start,len):
idx = start + np.arange(len)
idx_x2 = idx % 15345037
idx_a = idx % 15345000
hold = idx_a>=(15345000-1069)
idx_x2_a = idx_x2.copy()
idx_x2_a[hold] = 4091
p_x2a = x2a[idx_x2_a % 4092]
idx_b = idx % 15345000
hold = idx_b>=(15345000-965)
idx_x2_b = idx_x2.copy()
idx_x2_b[hold] = 4092
p_x2b = x2b[idx_x2_b % 4093]
return np.logical_xor(p_x2a,p_x2b)
def p_code(prn,start,len):
day = (prn-1)//37
prn = prn - 37*day
start += chip_rate*86400*day
start = start%code_length
p_x1 = x1(prn,start,len)
p_x2 = x2(prn,start-prn,len)
p_last_x2 = last_x2(prn,(start-prn)%code_length,len)
idx_x2 = (start - prn + | np.arange(len) | numpy.arange |
import numpy as np
from numpy.ma import isin
from scipy.ndimage.interpolation import affine_transform
import torch
import matplotlib.pyplot as plt
import os
from pathlib import Path
import glob
from torchvision.transforms import RandomAffine
import torchvision
import time
import random
import pickle
from PIL import Image
# import comet_ml
import io
class Profile(object):
def __enter__(self):
self.begin = time.time()
return self
def __exit__(self,type, value, traceback):
self.period = time.time()-self.begin
def __call__(self):
return self.period
class averageArray():
def __init__(self,dim=0,MIN=1000,MAX=-1000):
self.dim = dim
self.sum = np.zeros(dim)
self.avg = np.zeros(dim)
self.min = np.full(shape=(self.dim),fill_value=MIN)
self.max = np.full(shape=(self.dim),fill_value=MAX)
self.count = 0
self.meta = []
self.metaarray = np.empty((1,dim))
def update(self,batch_data,need_abs=True):
'''value is a batch of data'''
assert isinstance(batch_data,np.ndarray) and batch_data.shape[1]==self.dim
self.meta.append(batch_data)
self.metaarray = np.concatenate(self.meta,axis=0)
batches = batch_data.shape[0]
if need_abs:
self.sum += np.abs(batch_data).sum(axis=0)
else:
self.sum += batch_data.sum(axis=0)
self.count += batches
self.avg = self.sum*1.0/self.count
self.val = batch_data
self.min = np.where(batch_data.min(axis=0)<self.min,batch_data.min(axis=0),self.min)
self.max = np.where(batch_data.max(axis=0)>self.max,batch_data.max(axis=0),self.max)
self.std = np.std(self.metaarray,axis=0)
class averageScalar():
def __init__(self):
self.count = 0
self.sum = 0
self.avg = 0
def update(self,value,bb):
self.count += bb
self.sum += value*bb
self.avg = self.sum/self.count
self.val = value
def draw_axis_on_img(img, yaw, pitch, roll, tdx=None, tdy=None, size = 50,thickness=(2,2,2)):
import cv2
"""
Function used to draw y (headpose label) on Input Image x.
Implemented by: shamangary
https://github.com/shamangary/FSA-Net/blob/master/demo/demo_FSANET.py
Modified by: <NAME>
"""
pitch = pitch * np.pi / 180
yaw = -(yaw * np.pi / 180)
roll = roll * np.pi / 180
if tdx != None and tdy != None:
tdx = tdx
tdy = tdy
else:
height, width = img.shape[:2]
tdx = width / 2
tdy = height / 2
# X-Axis pointing to right. drawn in red
x1 = size * (np.cos(yaw) * np.cos(roll)) + tdx
y1 = size * (np.cos(pitch) * np.sin(roll) + np.cos(roll) * np.sin(pitch) * np.sin(yaw)) + tdy
# Y-Axis | drawn in green
# v
x2 = size * (-np.cos(yaw) * np.sin(roll)) + tdx
y2 = size * (np.cos(pitch) * np.cos(roll) - np.sin(pitch) * np.sin(yaw) * np.sin(roll)) + tdy
# Z-Axis (out of the screen) drawn in blue
x3 = size * (np.sin(yaw)) + tdx
y3 = size * (-np.cos(yaw) * np.sin(pitch)) + tdy
cv2.line(img, (int(tdx), int(tdy)), (int(x1),int(y1)),(0,0,255),thickness[0])
cv2.line(img, (int(tdx), int(tdy)), (int(x2),int(y2)),(0,255,0),thickness[1])
cv2.line(img, (int(tdx), int(tdy)), (int(x3),int(y3)),(255,0,0),thickness[2])
return img
def save_model(model,optim,lr_scheduler,epoch,eval_error,path):
if hasattr(model,"module"):
model_state = model.module.state_dict()
else:
model_state = model.state_dict()
if lr_scheduler is None:
torch.save({"model":model_state,"optim":optim.state_dict(),"epoch":epoch,"eval_error":eval_error},path)
else:
torch.save({"model":model_state,"optim":optim.state_dict(),"lr_scheduler":lr_scheduler.state_dict(),"epoch":epoch,"eval_error":eval_error},path)
def load_model(model,ckp_path):
def remove_module_string(k):
items = k.split(".")
items = items[0:1] + items[2:]
return ".".join(items)
if isinstance(ckp_path,str):
ckp = torch.load(ckp_path,map_location = lambda storage,loc:storage)
ckp_model_dict = ckp['model']
else:
ckp_model_dict = ckp_path
example_key = list(ckp_model_dict.keys())[0]
if "module" in example_key:
ckp_model_dict = {remove_module_string(k):v for k,v in ckp_model_dict.items()}
if hasattr(model,"module"):
model.module.load_state_dict(ckp_model_dict)
else:
model.load_state_dict(ckp_model_dict)
def generate_random_seed():
seed = hash(time.time()) % 10000
return seed
def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
def my_load_state_dict_with_filter(model,ckp_path):
ckp = torch.load(ckp_path,lambda storage,_:storage)
ckp_state_dict = ckp['model']
model_state_dict = model.state_dict()
to_be_updated = {k:v for k,v in ckp_state_dict.items() if k in model_state_dict and v.shape==model_state_dict[k].shape}
model_state_dict.update(to_be_updated)
print("length of pretained weights: ",len(list(to_be_updated.keys())))
model.load_state_dict(model_state_dict)
def string_for_loss(names,losses):
str = ""
for name,loss in zip(names,losses):
if isinstance(loss,torch.Tensor):
loss = loss.item()
str = str+f"{name}: {loss:.2f}\t"
return str
def get_grad_norm(parameters, norm_type=2):
if isinstance(parameters, torch.Tensor):
parameters = [parameters]
parameters = list(filter(lambda p: p.grad is not None, parameters))
norm_type = float(norm_type)
total_norm = 0
for p in parameters:
param_norm = p.grad.data.norm(norm_type)
total_norm += param_norm.item() ** norm_type
total_norm = total_norm ** (1. / norm_type)
return torch.tensor(total_norm)
def fig2img(fig):
"""Convert a Matplotlib figure to a PIL Image and return it"""
buf = io.BytesIO()
fig.savefig(buf)
buf.seek(0)
img = Image.open(buf)
return img
def compute_rotated_position(abs_position,init_position,init_yaw,single=True):
init_yaw = np.pi*init_yaw/180
if single:
x_hat = np.array([np.cos(init_yaw), -np.sin(init_yaw)])
y_hat = np.array([np.cos(np.pi/2.0-init_yaw), np.sin(np.pi/2.0-init_yaw)])
else:
x_hat = np.stack([ | np.cos(init_yaw) | numpy.cos |
import numpy as np
def glog(im_input, alpha=1, range=None, theta=np.pi/4, tau=0.6, eps=0.6):
"""Performs generalized Laplacian of Gaussian blob detection.
Parameters
----------
im_input : array_like
A hematoxylin intensity image obtained from ColorDeconvolution.
alpha : double
A positive scalar used to normalize the gLoG filter responses. Controls
the blob-center detection and eccentricities of detected blobs. Larger
values emphasize more eccentric blobs. Default value = 1.
range : array_like
Scale range
theta : double
Angular increment for rotating gLoG filters. Default value = np.pi / 6.
tau : double
Tolerance for counting pixels in determining optimal scale SigmaC
eps : double
range to define SigmaX surrounding SigmaC
Returns
-------
Rsum : array_like
Sum of filter responses at specified scales and orientations
Maxima: : array_like
A binary mask highlighting maxima pixels
Notes
-----
Return values are returned as a namedtuple
References
----------
.. [#] <NAME>, <NAME>, <NAME>, "A Generalized Laplacian of
Gaussian Filter for Blob Detection and Its Applications," in IEEE
Transactions on Cybernetics, vol.43,no.6,pp.1719-33, 2013.
"""
import scipy.ndimage as ndi
from skimage import morphology
range = np.linspace(1.5, 3, int(np.round((3 - 1.5) / 0.2)) + 1) if range is None else range
# initialize sigma
Sigma = np.exp(range)
# generate circular LoG scale-space to determine range of SigmaX
l_g = 0
H = []
Bins = []
Min = np.zeros((len(Sigma), 1))
Max = np.zeros((len(Sigma), 1))
for i, s in enumerate(Sigma):
Response = s**2 * ndi.filters.gaussian_laplace(im_input, s, output=None,
mode='constant',
cval=0.0)
Min[i] = Response.min()
Max[i] = Response.max()
Bins.append(np.arange(0.01 * np.floor(Min[i] / 0.01),
0.01 * np.ceil(Max[i] / 0.01) + 0.01, 0.01))
Hist = np.histogram(Response, Bins[i])
H.append(Hist[0])
if Max[i] > l_g:
l_g = Max[i]
# re-normalized based on global max and local min, count threshold pixels
Zeta = np.zeros((len(Sigma), 1))
for i, s in enumerate(Sigma):
Bins[i] = (Bins[i] - Min[i]) / (l_g - Min[i])
Zeta[i] = np.sum(H[i][Bins[i][0:-1] > tau])
# identify best scale SigmaC based on maximum circular response
Index = np.argmax(Zeta)
# define range for SigmaX
XRange = range(max(Index-2, 0), min(len(range), Index + 2) + 1)
SigmaX = np.exp(range[XRange])
# define rotation angles
Thetas = np.linspace(0, np.pi - theta, int(np.round(np.pi / theta)))
# loop over SigmaX, SigmaY and then angle, summing up filter responses
Rsum = | np.zeros(im_input.shape) | numpy.zeros |
# -*- coding: utf-8 -*-
# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
#
# fluctmatch --- https://github.com/tclick/python-fluctmatch
# Copyright (c) 2013-2017 The fluctmatch Development Team and contributors
# (see the file AUTHORS for the full list of names)
#
# Released under the New BSD license.
#
# Please cite your use of fluctmatch in published work:
#
# <NAME>, <NAME>, and <NAME>.
# Calculation of Enzyme Fluctuograms from All-Atom Molecular Dynamics
# Simulation. Meth Enzymology. 578 (2016), 327-342,
# doi:10.1016/bs.mie.2016.05.024.
#
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
from future.builtins import (
super, )
import numpy as np
from MDAnalysis.core import selection
class BioIonSelection(selection.Selection):
"""Contains atoms commonly found in proteins.
"""
token = "bioion"
ion_atoms = np.array(["MG", "CAL", "MN", "FE", "CU", "ZN", "AG"])
def __init__(self, parser, tokens):
pass
def apply(self, group):
mask = np.in1d(group.names, self.ion_atoms)
return group[mask].unique
class WaterSelection(selection.Selection):
"""Contains atoms commonly found in water.
"""
token = "water"
water_atoms = np.array(["OW", "HW1", "HW2", "MW"])
def __init__(self, parser, tokens):
pass
def apply(self, group):
mask = np.in1d(group.names, self.water_atoms)
return group[mask].unique
class BackboneSelection(selection.BackboneSelection):
"""Contains all heavy atoms within a protein backbone including the terminal carboxyl oxygens.
"""
token = "backbone"
oxy_atoms = ["OXT", "OT1", "OT2"]
def apply(self, group):
mask = np.in1d(group.names,
np.concatenate([self.bb_atoms, self.oxy_atoms]))
mask &= np.in1d(group.resnames, self.prot_res)
return group[mask].unique
class HBackboneSelection(BackboneSelection):
"""Includes all atoms found within a protein backbone including hydrogens.
"""
token = "hbackbone"
hbb_atoms = np.array([
"H", "HN", "H1", "H2", "H3", "HT1", "HT2", "HT3", "HA", "HA1", "HA2",
"1HA", "2HA"
])
def apply(self, group):
mask = np.in1d(group.names,
np.concatenate(
[self.bb_atoms, self.oxy_atoms, self.hbb_atoms]))
mask &= np.in1d(group.resnames, self.prot_res)
return group[mask].unique
class CalphaSelection(selection.ProteinSelection):
"""Contains only the alpha-carbon of a protein.
"""
token = "calpha"
calpha = np.array(["CA"])
def apply(self, group):
mask = np.in1d(group.names, self.calpha)
mask &= np.in1d(group.resnames, self.prot_res)
return group[mask].unique
class HCalphaSelection(CalphaSelection):
"""Contains the alpha-carbon and alpha-hydrogens of a protein.
"""
token = "hcalpha"
hcalpha = np.array(["HA", "HA1", "HA2", "1HA", "2HA"])
def apply(self, group):
mask = np.in1d(group.names, np.concatenate([self.calpha,
self.hcalpha]))
mask &= np.in1d(group.resnames, self.prot_res)
return group[mask].unique
class CbetaSelection(selection.ProteinSelection):
"""Contains only the beta-carbon of a protein.
"""
token = "cbeta"
cbeta = np.array(["CB"])
def apply(self, group):
mask = np.in1d(group.names, self.cbeta)
mask &= np.in1d(group.resnames, self.prot_res)
return group[mask].unique
class AmineSelection(selection.ProteinSelection):
"""Contains atoms within the amine group of a protein.
"""
token = "amine"
amine = np.array(["N", "HN", "H", "H1", "H2", "H3", "HT1", "HT2", "HT3"])
def apply(self, group):
mask = | np.in1d(group.names, self.amine) | numpy.in1d |
import cv2
import numpy as np
import scipy.optimize
import recordreader
WHEELTICK_SCALE = 0.066
CAM_TILT = np.array([0, 22.*np.pi/180., 0])
K = np.load("../../tools/camcal/camera_matrix.npy")
dist = np.load("../../tools/camcal/dist_coeffs.npy")
K[:2] /= 4.05
fx, fy = np.diag(K)[:2]
cx, cy = K[:2, 2]
mapsz = 300 # map size
Z = 14 # map zoom factor
uv = np.mgrid[:480, :640][[1, 0]].transpose(1, 2, 0).astype(np.float32)
ceilmask = ((uv[:, :, 1] - cy)**2 + (uv[:, :, 0] - cx + 60)**2) < (np.pi/2.4 * fx)**2
R = cv2.Rodrigues(CAM_TILT)[0]
pts = cv2.fisheye.undistortPoints(uv[None, ceilmask], K, dist, R=R)
ceilmap = np.zeros((mapsz, mapsz), np.float32)
ceilN = np.ones((mapsz, mapsz), np.float32)
ceilmean = ceilmap / ceilN
def pix2floormap():
''' undistortPoints doesn't support points behind the image plane, but we can solve for them '''
def solvetheta(thetad, k1):
theta = thetad
theta += (theta*(k1*theta**2 + 1) - thetad)/(-3*k1*theta**2 - 1)
theta += (theta*(k1*theta**2 + 1) - thetad)/(-3*k1*theta**2 - 1)
return theta
mg = np.mgrid[:480, :640]
u, v = (mg[1] - cx)/fx, (mg[0] - cy)/fy
r = np.sqrt(u**2 + v**2)
a, b = u/r, -v/r
theta = solvetheta(r, dist[0])
mask = (theta > np.pi/2) & (theta < np.pi/1.9)
t = 1.0 / np.tan(theta[mask] - np.pi/2)
return mask, np.stack([a[mask] * t, b[mask] * t]).T
floormap = np.zeros((mapsz, mapsz, 3), np.float32)
floorN = np.ones((mapsz, mapsz), np.float32) * 1e-3
floormean = floormap / floorN[:, :, None]
floormask, floorpts = pix2floormap()
def Maplookup(x, y, theta):
S, C = np.sin(theta), np.cos(theta)
R = np.array([[C, S], [-S, C]])*Z
p = np.dot(pts[0], R.T) + np.array([x, y])
pi = p.astype(np.int)
pt = p - pi
t00 = (1-pt[:, 1])*(1-pt[:, 0])
t01 = (1-pt[:, 1])*(pt[:, 0])
t10 = (pt[:, 1])*(1-pt[:, 0])
t11 = (pt[:, 1])*(pt[:, 0])
m = (t00*ceilmean[pi[:, 1], pi[:, 0]+1] +
t01*ceilmean[pi[:, 1], pi[:, 0]+1] +
t10*ceilmean[pi[:, 1]+1, pi[:, 0]+1] +
t11*ceilmean[pi[:, 1]+1, pi[:, 0]+1])
return m
def Mapupdate(xi, yi, theta, gray):
S, C = np.sin(theta), np.cos(theta)
R = np.array([[C, S], [-S, C]])*Z
p = np.dot(pts[0], R.T) + np.array([xi, yi])
pi = p.astype(np.int)
pt = p - pi
t00 = (1-pt[:, 1])*(1-pt[:, 0])
t01 = (1-pt[:, 1])*(pt[:, 0])
t10 = (pt[:, 1])*(1-pt[:, 0])
t11 = (pt[:, 1])*(pt[:, 0])
idxs = pi[:, 1] * mapsz + pi[:, 0]
ceilN[:] += np.bincount(idxs, t00.reshape(-1), mapsz*mapsz).reshape(mapsz, mapsz)
ceilN[:] += np.bincount(idxs+1, t01.reshape(-1), mapsz*mapsz).reshape(mapsz, mapsz)
ceilN[:] += np.bincount(idxs+mapsz, t10.reshape(-1), mapsz*mapsz).reshape(mapsz, mapsz)
ceilN[:] += np.bincount(idxs+mapsz+1, t11.reshape(-1), mapsz*mapsz).reshape(mapsz, mapsz)
mask = ceilmask
ceilmap[:] += np.bincount(idxs, t00*gray[mask], mapsz*mapsz).reshape(mapsz, mapsz)
ceilmap[:] += np.bincount(idxs+1, t01*gray[mask], mapsz*mapsz).reshape(mapsz, mapsz)
ceilmap[:] += | np.bincount(idxs+mapsz, t10*gray[mask], mapsz*mapsz) | numpy.bincount |
import sys
import io
import numpy as np
import scipy
import math
import gzip
class SkvpVideoInvalidInitError(Exception):
pass
class SkvpVideoInvalidValueError(Exception):
pass
class SkvpForbiddenOperationError(Exception):
pass
class SkvpFileSyntaxError(Exception):
pass
class SkvpUsageError(Exception):
pass
SKVP_HEADER_TITLE_LINE = '*SKeleton Video Player File Header*'
SKVP_VIDEO_TITLE_LINE = '*Video*'
SKVP_HEADER_NUM_JOINTS_ENTRY = 'NumJoints'
SKVP_HEADER_NUM_FRAMES_ENTRY = 'NumberOfFrames'
SKVP_HEADER_FPS_ENTRY = 'FPS'
SKVP_HEADER_CONNECTIONS_ENTRY = 'Connections'
SKVP_HEADER_JOINT_RADIUSES_ENTRY = 'JointRadiuses'
SKVP_HEADER_CONNECTIONS_RADIUS_ENTRY = 'ConnectionsRadius'
SKVP_HEADER_CAMERA_LOCATION_ENTRY = 'CameraLocation'
SKVP_HEADER_CAMERA_DESTINATION_ENTRY = 'CameraDestination'
SKVP_HEADER_CAMERA_SCENE_ROTATION_ENTRY = 'CameraSceneRotation'
class SkvpVideo:
def __init__(self, input_file_handler = None, fps = None, num_joints = None,
connections = None, joint_radiuses = None,
connections_radius = None, camera_location = None,
camera_destination = None, camera_scene_rotation = None):
got_parameters = fps != None or num_joints != None or connections != None or joint_radiuses != None or connections_radius != None or camera_location != None or camera_destination != None or camera_scene_rotation != None
if input_file_handler != None:
if got_parameters:
raise SkvpVideoInvalidInitError('Cannot specify both input file header and Skvp parameters')
self.parse_skvp_file(input_file_handler)
return
self.set_fps(fps)
self.set_num_joints(num_joints)
self.set_connections(connections)
self.set_joint_radiuses(joint_radiuses)
self.set_connections_radius(connections_radius)
self.set_camera_location(camera_location)
self.set_camera_destination(camera_destination)
self.set_camera_scene_rotation(camera_scene_rotation)
self.frames = []
self.invideo_camera_settings = {}
def validate_fps(self, fps):
if fps == None:
return
if not (type(fps) is int or type(fps) is float):
raise SkvpVideoInvalidValueError('\'fps\' must be a positive real number')
if fps <= 0:
raise SkvpVideoInvalidValueError('\'fps\' must be a positive real number')
def set_fps(self, fps):
self.validate_fps(fps)
self.fps = fps if fps != None else None
def get_fps(self):
return self.fps
def validate_num_joints(self, num_joints):
if hasattr(self, 'frames'):
if len(self.frames) > 0:
raise SkvpForbiddenOperationError('Cannot modify number of joints while frames list is not empty')
if hasattr(self, 'connections'):
if self.connections != None and len(self.connections) > 0:
raise SkvpForbiddenOperationError('Cannot modify number of joints while connections list is not empty')
if hasattr(self, 'joint_radiuses'):
if self.joint_radiuses != None and len(self.joint_radiuses) > 0:
raise SkvpForbiddenOperationError('Cannot modify number of joints while joint radiuses are defined')
if num_joints == None:
return
if not (type(num_joints) is int):
raise SkvpVideoInvalidValueError('\'num_joints\' must be a positive integer')
if num_joints <= 0:
raise SkvpVideoInvalidValueError('\'num_joints\' must be a positive integer')
def set_num_joints(self, num_joints):
self.validate_num_joints(num_joints)
self.num_joints = num_joints if num_joints != None else None
def get_num_joints(self):
return self.num_joints
def validate_connections(self, connections):
if connections == None:
return
if len(connections) == 0:
return
if not hasattr(self, 'num_joints'):
raise SkvpForbiddenOperationError('Cannot define connections while number of joints is not defined')
if self.num_joints == None:
raise SkvpForbiddenOperationError('Cannot define connections while number of joints is not defined')
for (j1, j2) in connections:
if not (type(j1) is int and type(j2) is int):
raise SkvpVideoInvalidValueError('Joint numbers must be integers between 1 and NUM_JOINTS')
if j1 < 1 or j1 > self.num_joints or j2 < 1 or j2 > self.num_joints:
raise SkvpVideoInvalidValueError('Joint numbers must be integers between 1 and NUM_JOINTS')
if j1 == j2:
raise SkvpVideoInvalidValueError('Cannot define a connection from a joint into itself')
def set_connections(self, connections):
self.validate_connections(connections)
self.connections = tuple(connections) if connections != None else None
def get_connections(self):
return self.connections
def validate_joint_radiuses(self, joint_radiuses):
if joint_radiuses == None:
return
if len(joint_radiuses) == 0:
return
if not hasattr(self, 'num_joints'):
raise SkvpForbiddenOperationError('Cannot define joint radiuses while number of joints is not defined')
if self.num_joints == None:
raise SkvpForbiddenOperationError('Cannot define joint radiuses while number of joints is not defined')
if len(joint_radiuses) != self.num_joints:
raise SkvpVideoInvalidValueError('Joint radiuses array must contain exactly J values, where J is number of joints')
for val in joint_radiuses:
if not (type(val) is int or type(val) is float):
raise SkvpVideoInvalidValueError('Joint radiuses must be non-negative real numbers')
if val < 0:
raise SkvpVideoInvalidValueError('Joint radiuses must be non-negative real numbers')
def set_joint_radiuses(self, joint_radiuses):
self.validate_joint_radiuses(joint_radiuses)
self.joint_radiuses = tuple(joint_radiuses) if joint_radiuses != None else None
def get_joint_radiuses(self):
return self.joint_radiuses
def validate_connections_radius(self, connections_radius):
if connections_radius == None:
return
if not (type(connections_radius) is int or type(connections_radius) is float):
raise SkvpVideoInvalidValueError('Connections radius must be a single non_negative real number')
if connections_radius < 0:
raise SkvpVideoInvalidValueError('Connections radius must be a single non_negative real number')
def set_connections_radius(self, connections_radius):
self.validate_connections_radius(connections_radius)
self.connections_radius = connections_radius if connections_radius != None else None
def get_connections_radius(self):
return self.connections_radius
def validate_camera_coordinate(self, camera_coordinate, coordinate_type):
if camera_coordinate == None:
return
if len(camera_coordinate) != 3:
raise SkvpVideoInvalidValueError('Camera {0} should be an array containing 3 numbers (X,Y,Z)'.format(coordinate_type))
for val in camera_coordinate:
val_type = type(val)
if not (val_type is int or val_type is float):
raise SkvpVideoInvalidValueError('Camera (X,Y,Z) coordinates must be real numbers')
def set_camera_location(self, camera_location):
self.validate_camera_coordinate(camera_location, 'location')
self.camera_location = tuple(camera_location) if camera_location != None else None
def get_camera_location(self):
return self.camera_location
def set_camera_destination(self, camera_destination):
self.validate_camera_coordinate(camera_destination, 'destination')
self.camera_destination = tuple(camera_destination) if camera_destination != None else None
def get_camera_destination(self):
return self.camera_destination
def validate_camera_scene_rotation(self, camera_scene_rotation):
if camera_scene_rotation == None:
return
val_type = type(camera_scene_rotation)
if not (val_type is int or val_type is float):
raise SkvpVideoInvalidValueError('Camera scene rotation must be a real number')
def set_camera_scene_rotation(self, camera_scene_rotation):
self.validate_camera_scene_rotation(camera_scene_rotation)
self.camera_scene_rotation = camera_scene_rotation if camera_scene_rotation != None else None
def get_camera_scene_rotation(self):
return self.camera_scene_rotation
def add_frame(self, joint_locations_iterable):
if not hasattr(self, 'num_joints'):
raise SkvpForbiddenOperationError('Cannot add frames while number of joints is not defined')
if self.num_joints == None:
raise SkvpForbiddenOperationError('Cannot add frames while number of joints is not defined')
frame = [np.array(joint_loc) for joint_loc in joint_locations_iterable]
if len(frame) != self.num_joints:
raise SkvpVideoInvalidValueError('Frame joint locations must contain exactly J locations, where J is number of joints')
self.frames.append(frame)
def set_frame_camera_settings(self, i, camera_settings):
if i < 0 or i >= len(self.num_frames):
raise SkvpForbiddenOperationError('Index out of bounds')
self.invideo_camera_settings[i] = camera_settings
def get_frame_camera_settings(self, i):
# This method returns the **LATEST**, *invideo* camera settings for frame i (can be defined in less than i)
if i < 0 or i >= len(self.frames):
raise SkvpForbiddenOperationError('frame index is out of video bounds: ' + str(i))
# We want to find largest index that is smaller or equals to i
if len(self.invideo_camera_settings) == 0:
return None
if i in self.invideo_camera_settings:
return self.invideo_camera_settings[i]
relevant_frames = sorted([frame_num for frame_num in self.invideo_camera_settings.keys() if frame_num <= i])
if len(relevant_frames) == 0:
return None
return self.invideo_camera_settings[relevant_frames[-1]]
def get_video_length(self, seconds = False):
if seconds:
if self.fps == None:
raise SkvpForbiddenOperationError('Cannot calculate length in seconds while FPS is not defined')
return len(self.frames) / float(self.fps)
return len(self)
def __len__(self):
return len(self.frames)
def __getitem__(self, val):
if type(val) is int:
start = len(self) + val if val < 0 else val
end = start + 1
step = 1
elif type(val) is slice:
start = val.start
end = val.stop
step = val.step
if start == None:
start = 0
if end == None:
end = len(self)
if step == None:
step = 1
if not (type(start) is int and type(end) is int and type(step) is int):
raise SkvpForbiddenOperationError('Slicing parameters must be integers')
new_vid = SkvpVideo(fps = self.fps, num_joints = self.num_joints, connections = self.connections, joint_radiuses = self.joint_radiuses, connections_radius = self.connections_radius, camera_location = self.camera_location, camera_destination = self.camera_destination, camera_scene_rotation = self.camera_scene_rotation)
new_vid.frames = self.frames[start:end:step]
start_pos = (len(self) + start) if start < 0 else start
end_pos = (len(self) + end) if end < 0 else end
last_camera_settings = None
for i, frame_key in enumerate(range(start_pos, end_pos, step)):
camera_settings = self.get_frame_camera_settings(frame_key)
if camera_settings != None:
if camera_settings == last_camera_settings:
continue
new_vid.invideo_camera_settings[i] = dict(camera_settings)
last_camera_settings = camera_settings
return new_vid
def __add__(self, vid_2):
if type(vid_2) is not SkvpVideo:
raise SkvpForbiddenOperationError('Cannot add a non SkvpVideo object')
if self.num_joints != vid_2.num_joints:
raise SkvpForbiddenOperationError('Cannot add two videos with different number of joints')
if self.fps != vid_2.fps:
sys.stderr.write('Warning: adding videos with mismatching frame rates. Frames will be copied without modification\n')
new_vid = SkvpVideo(fps = self.fps, num_joints = self.num_joints, connections = self.connections, joint_radiuses = self.joint_radiuses, connections_radius = self.connections_radius, camera_location = self.camera_location, camera_destination = self.camera_destination, camera_scene_rotation = self.camera_scene_rotation)
new_vid.frames = self.frames + vid_2.frames
for frame_index, camera_settings in self.invideo_camera_settings.items():
new_vid.invideo_camera_settings[frame_index] = dict(camera_settings)
num_frames_self = len(self)
for frame_index, camera_settings in vid_2.invideo_camera_settings.items():
new_vid.invideo_camera_settings[frame_index + num_frames_self] = dict(camera_settings)
if num_frames_self not in new_vid.invideo_camera_settings:
camera_settings = {}
if vid_2.get_camera_location() != None:
camera_settings['camera_location'] = vid_2.get_camera_location()
if vid_2.get_camera_destination() != None:
camera_settings['camera_destination'] = vid_2.get_camera_destination()
if vid_2.get_camera_scene_rotation() != None:
camera_settings['camera_scene_rotation'] = vid_2.get_camera_scene_rotation()
if len(camera_settings) > 0:
new_vid.invideo_camera_settings[num_frames_self] = camera_settings
return new_vid
def dump(skvp_video, ostream_or_filename):
if type(ostream_or_filename).__name__ == 'str':
self_opened = True
if ostream_or_filename.lower().endswith('.gz'):
ostream = gzip.open(ostream_or_filename, 'wt')
else:
ostream = open(ostream_or_filename, 'w')
else:
self_opened = False
ostream = ostream_or_filename
self = skvp_video
if self.fps == None:
raise SkvpForbiddenOperationError('Cannot dump SkvpVideo while FPS is not defined')
if self.num_joints == None:
raise SkvpForbiddenOperationError('Cannot dump SkvpVideo while number of joints is not defined')
ostream.write(SKVP_HEADER_TITLE_LINE)
ostream.write('\n')
ostream.write('{0}={1}'.format(SKVP_HEADER_NUM_JOINTS_ENTRY, str(self.num_joints)))
ostream.write('\n')
ostream.write('{0}={1}'.format(SKVP_HEADER_NUM_FRAMES_ENTRY, str(len(self.frames))))
ostream.write('\n')
ostream.write('{0}={1}'.format(SKVP_HEADER_FPS_ENTRY, str(self.fps)))
ostream.write('\n')
if self.connections != None:
ostream.write('{0}={1}'.format(SKVP_HEADER_CONNECTIONS_ENTRY, ','.join(['{0}-{1}'.format(str(c[0]), str(c[1])) for c in self.connections])))
ostream.write('\n')
if self.joint_radiuses != None:
ostream.write('{0}={1}'.format(SKVP_HEADER_JOINT_RADIUSES_ENTRY, ','.join([str(val) for val in self.joint_radiuses])))
ostream.write('\n')
if self.connections_radius != None:
ostream.write('{0}={1}'.format(SKVP_HEADER_CONNECTIONS_RADIUS_ENTRY, str(self.connections_radius)))
ostream.write('\n')
if self.camera_location != None:
ostream.write('{0}={1}'.format(SKVP_HEADER_CAMERA_LOCATION_ENTRY, ','.join([str(val) for val in self.camera_location])))
ostream.write('\n')
if self.camera_destination != None:
ostream.write('{0}={1}'.format(SKVP_HEADER_CAMERA_DESTINATION_ENTRY, ','.join([str(val) for val in self.camera_destination])))
ostream.write('\n')
if self.camera_scene_rotation != None:
ostream.write('{0}={1}'.format(SKVP_HEADER_CAMERA_SCENE_ROTATION_ENTRY, str(self.camera_scene_rotation)))
ostream.write('\n')
ostream.write('\n')
ostream.write(SKVP_VIDEO_TITLE_LINE)
ostream.write('\n')
for i, frame in enumerate(self.frames):
if i in self.invideo_camera_settings:
if 'camera_location' in self.invideo_camera_settings[i]:
ostream.write('{0}={1}'.format(SKVP_HEADER_CAMERA_LOCATION_ENTRY, ','.join([str(val) for val in self.invideo_camera_settings[i]['camera_location']])))
ostream.write('\n')
if 'camera_destination' in self.invideo_camera_settings[i]:
ostream.write('{0}={1}'.format(SKVP_HEADER_CAMERA_DESTINATION_ENTRY, ','.join([str(val) for val in self.invideo_camera_settings[i]['camera_destination']])))
ostream.write('\n')
if 'camera_scene_rotation' in self.invideo_camera_settings[i]:
ostream.write('{0}={1}'.format(SKVP_HEADER_CAMERA_SCENE_ROTATION_ENTRY, str(self.invideo_camera_settings[i]['camera_scene_rotation'])))
ostream.write('\n')
ostream.write(';'.join([','.join([str(coor) for coor in joint_xyz]) for joint_xyz in frame]))
if i < len(self.frames) - 1:
ostream.write('\n')
if self_opened:
ostream.close()
def dumps(skvp_video):
string_stream = io.StringIO()
dump(skvp_video, string_stream)
return string_stream.getvalue()
def find_skvp_header_beginning(istream):
while True:
line = istream.readline()
if line == '': # Empty line within file must contain '\n' char
raise SkvpFileSyntaxError('SKVP file is empty')
line = line.strip()
if line == '':
continue
if line == SKVP_HEADER_TITLE_LINE:
return
raise SkvpFileSyntaxError('SKVP file must start with line: ' + SKVP_HEADER_TITLE_LINE)
def find_skvp_video_start_and_get_header(istream):
header = {}
while True:
line = istream.readline()
if line == '': # Empty line within file must contain '\n' char
raise SkvpFileSyntaxError('Could not find line which indicates starting of video: ' + SKVP_VIDEO_TITLE_LINE)
line = line.strip()
if line == '':
continue
if line == SKVP_VIDEO_TITLE_LINE:
return header
parts = line.split('=', 1)
if len(parts) != 2:
raise SkvpFileSyntaxError('Header lines must be in the format: ENTRY_NAME=ENTRY_VALUE')
header[parts[0].strip()] = parts[1].strip()
def header_to_video_object(header, skvp_video):
if SKVP_HEADER_NUM_JOINTS_ENTRY not in header:
raise SkvpFileSyntaxError('Header does not contain entry: ' + SKVP_HEADER_NUM_JOINTS_ENTRY)
try:
num_joints = int(header[SKVP_HEADER_NUM_JOINTS_ENTRY])
except:
raise SkvpFileSyntaxError(SKVP_HEADER_NUM_JOINTS_ENTRY + ' must be a natural number')
skvp_video.set_num_joints(num_joints)
if SKVP_HEADER_FPS_ENTRY not in header:
raise SkvpFileSyntaxError('Header does not contain entry: ' + SKVP_HEADER_FPS_ENTRY)
try:
fps = float(header[SKVP_HEADER_FPS_ENTRY])
except:
raise SkvpFileSyntaxError(SKVP_HEADER_FPS_ENTRY + ' must be a real number')
skvp_video.set_fps(fps)
if SKVP_HEADER_CONNECTIONS_ENTRY in header:
try:
connections = [(int(p.split('-')[0]), int(p.split('-')[1])) for p in header[SKVP_HEADER_CONNECTIONS_ENTRY].split(',')]
except:
raise SkvpFileSyntaxError(SKVP_HEADER_CONNECTIONS_ENTRY + ' must be pairs of natural numbers separated by commas, where each pair is separated by a hyphen')
skvp_video.set_connections(connections)
if SKVP_HEADER_JOINT_RADIUSES_ENTRY in header:
try:
radiuses = [float(rad) for rad in header[SKVP_HEADER_JOINT_RADIUSES_ENTRY].split(',')]
except:
raise SkvpFileSyntaxError(SKVP_HEADER_JOINT_RADIUSES_ENTRY + ' must be a list of real numbers, separated by commas')
skvp_video.set_joint_radiuses(radiuses)
if SKVP_HEADER_CONNECTIONS_RADIUS_ENTRY in header:
try:
radius = float(header[SKVP_HEADER_CONNECTIONS_RADIUS_ENTRY])
except:
raise SkvpFileSyntaxError(SKVP_HEADER_CONNECTIONS_RADIUS_ENTRY + ' must be a real number')
skvp_video.set_connections_radius(radius)
if SKVP_HEADER_CAMERA_LOCATION_ENTRY in header:
try:
location = [float(val) for val in header[SKVP_HEADER_CAMERA_LOCATION_ENTRY].split(',')]
except:
raise SkvpFileSyntaxError(SKVP_HEADER_CAMERA_LOCATION_ENTRY + ' must be a list of real numbers, separated by commas')
skvp_video.set_camera_location(location)
if SKVP_HEADER_CAMERA_DESTINATION_ENTRY in header:
try:
destination = [float(val) for val in header[SKVP_HEADER_CAMERA_DESTINATION_ENTRY].split(',')]
except:
raise SkvpFileSyntaxError(SKVP_HEADER_CAMERA_DESTINATION_ENTRY + ' must be a list of real numbers, separated by commas')
skvp_video.set_camera_destination(destination)
if SKVP_HEADER_CAMERA_SCENE_ROTATION_ENTRY in header:
try:
rotation = float(header[SKVP_HEADER_CAMERA_SCENE_ROTATION_ENTRY])
except:
raise SkvpFileSyntaxError(SKVP_HEADER_CAMERA_SCENE_ROTATION_ENTRY + ' must be a real number')
skvp_video.set_camera_scene_rotation(rotation)
def get_invideo_camera_parameter(line):
parts = line.split('=', 1)
if len(parts) != 2:
raise SkvpFileSyntaxError('Invalid invideo camera settings line: ' + line)
return parts[1].strip()
def read_frames_into_video_object(istream, skvp_video):
num_frames_read = 0
camera_location = None
camera_destination = None
camera_scene_rotation = None
while True:
line = istream.readline()
if line == '': # Empty line within file must contain '\n' char
break
line = line.strip()
if line == '':
continue
if line.startswith(SKVP_HEADER_CAMERA_LOCATION_ENTRY):
param_str = get_invideo_camera_parameter(line)
continue
elif line.startswith(SKVP_HEADER_CAMERA_DESTINATION_ENTRY):
param_str = get_invideo_camera_parameter(line)
continue
elif line.startswith(SKVP_HEADER_CAMERA_SCENE_ROTATION_ENTRY):
param_str = get_invideo_camera_parameter(line)
continue
joint_locations_as_strings = line.split(';')
joint_locations_as_np_arrays = [np.array([float(coor) for coor in joint_loc_str.split(',')]) for joint_loc_str in joint_locations_as_strings]
skvp_video.add_frame(joint_locations_as_np_arrays)
camera_settings = {}
if camera_location != None:
camera_settings['camera_location'] = camera_location
if camera_destination != None:
camera_settings['camera_destination'] = camera_destination
if camera_scene_rotation != None:
camera_settings['camera_scene_rotation'] = camera_scene_roatation
if len(camera_settings) > 0:
skvp_video.set_frame_camera_settings(num_frames_read, camera_settings)
camera_location = None
camera_destination = None
camera_scene_rotation = None
num_frames_read += 1
def load(istream_or_filename):
if (type(istream_or_filename).__name__ == 'str'):
self_opened = True
if istream_or_filename.lower().endswith('.gz'):
istream = gzip.open(istream_or_filename, 'rt')
else:
istream = open(istream_or_filename, 'r')
else:
self_opened = False
istream = istream_or_filename
find_skvp_header_beginning(istream)
header = find_skvp_video_start_and_get_header(istream)
skvp_video = SkvpVideo()
header_to_video_object(header, skvp_video)
read_frames_into_video_object(istream, skvp_video)
if self_opened:
istream.close()
return skvp_video
def loads(video_string):
string_stream = io.StringIO(video_string)
return load(string_stream)
def create_length_scaled_video(ref_video, scale = None, num_frames = None, num_seconds = None):
if scale == None and num_frames == None and num_seconds == None:
raise SkvpUsageError('Must specify one of parameters {scale, num_frames, num_seconds}')
if (scale != None and num_frames != None) or (scale != None and num_seconds != None) or (num_frames != None and num_seconds != None):
raise SkvpUsageError('Must specify only one of parameters {scale, num_frames, num_seconds}')
if scale != None:
if not (type(scale) is int or type(scale) is float):
raise SkvpUsageError('scale parameter must be a number')
if scale <= 0:
raise SkvpForbiddenOperationError('Scale must be a positive real number')
if num_frames != None:
if not type(num_frames) is int:
raise SkvpUsageError('num_frames parameter must be an ineteger')
if num_frames <= 0:
raise SkvpForbiddenOperationError('Number of target frames must be a positive number')
if num_seconds != None:
if not (type(num_seconds) is int or type(num_seconds) is float):
raise SkvpUsageError('num_seconds parameter must be a number')
if num_seconds <= 0:
raise SkvpForbiddenOperationError('Number of target seconds must be a positive number')
if len(ref_video) == 0:
raise SkvpForbiddenOperationError('Cannot scale empty video')
final_scale = scale
if num_frames != None:
final_scale = num_frames / float(len(ref_video))
elif num_seconds != None:
final_scale = num_seconds / float(ref_video.get_video_length(seconds = True))
if final_scale == 1.0:
return ref_video[:]
new_vid = ref_video[0:0] # Creating empty video with same header
num_frames_target_vid = int(round(len(ref_video) * final_scale))
num_frames_ref_vid = len(ref_video)
for i in range(num_frames_target_vid):
if num_frames_target_vid == 1:
frame_perc = 0
else:
frame_perc = (i) / float(num_frames_target_vid - 1)
ref_frame = (num_frames_ref_vid - 1) * frame_perc
upper_weight = ref_frame - int(ref_frame)
lower_weight = 1.0 - upper_weight
lower_index = int(ref_frame)
if lower_weight == 1 or upper_weight == 1:
new_vid.add_frame(ref_video.frames[lower_index])
else:
new_frame = []
for j in range(ref_video.get_num_joints()):
new_frame.append(lower_weight * ref_video.frames[lower_index][j] + upper_weight * ref_video.frames[lower_index + 1][j])
new_vid.add_frame(new_frame)
return new_vid
def create_fps_changed_video(ref_video, new_fps):
if ref_video.fps == None:
raise SkvpForbiddenOperationError('Cannot create fps-changed video while reference video has no fps defined')
scale = float(new_fps) / ref_video.fps
new_vid = create_length_scaled_video(ref_video, scale = scale)
new_vid.set_fps(new_fps)
return new_vid
def gradient(ref_video):
new_vid = ref_video[0:0]
for i in range(len(ref_video) - 1):
next_frame = ref_video.frames[i + 1]
curr_frame = ref_video.frames[i]
der_frame = []
for next_joint, curr_joint in zip(next_frame, curr_frame):
der_frame.append(next_joint - curr_joint)
new_vid.add_frame(der_frame)
return new_vid
def equalize(ref_video, num_bins = None):
new_vid = ref_video[0:0]
num_frames = float(len(ref_video))
joint_vectors = []
if num_bins != None:
bin_size = int(round(len(ref_video) / float(num_bins)))
for i in range(ref_video.get_num_joints()):
joint_vectors.append([frame[i] for frame in ref_video.frames])
sorted_by_magnitude = sorted(range(len(joint_vectors[i])), key = lambda x : np.linalg.norm(joint_vectors[i][x]))
for j in range(len(sorted_by_magnitude)):
if num_bins == None:
coef = (j + 1) / num_frames
else:
bin_index = int(j / bin_size) + 1
if bin_index > num_bins:
bin_index -= 1
coef = (bin_index / float(num_bins))
frame_index = sorted_by_magnitude[j]
vec_norm = np.linalg.norm(joint_vectors[i][frame_index])
if vec_norm == 0:
vec_norm = 1
joint_vectors[i][frame_index] = (coef / vec_norm) * joint_vectors[i][frame_index]
for i in range(len(ref_video)):
frame = [joint_vec[i] for joint_vec in joint_vectors]
new_vid.add_frame(frame)
return new_vid
def norm(ref_video, selective_norm = False):
new_vid = ref_video[0:0]
if selective_norm:
joint_vec_sizes_opp = []
for i in range(ref_video.get_num_joints()):
joint_vec_sizes_opp.append([np.linalg.norm(ref_video.frames[frame_num][i]) ** (-1) for frame_num in range(len(ref_video))])
joint_nonorm_indices = []
for i in range(ref_video.get_num_joints()):
joint_opp_size_mean = np.mean(joint_vec_sizes_opp[i])
joint_nonorm_indices.append(set((frame_num for frame_num in range(len(joint_vec_sizes_opp[i])) if joint_vec_sizes_opp[i][frame_num] > joint_opp_size_mean)))
for i in range(len(ref_video)):
frame = []
for joint_num, joint in enumerate(ref_video.frames[i]):
if selective_norm and (i in joint_nonorm_indices[joint_num]):
frame.append(joint)
else:
vec_magn = np.linalg.norm(joint)
if vec_magn == 0:
vec_magn = 1
frame.append(joint / float(vec_magn))
new_vid.add_frame(frame)
return new_vid
def median(ref_video, mask_size = 3):
if mask_size <= 0 or mask_size % 2 != 1:
raise Exception('Mask size must be positive and odd')
if mask_size > len(ref_video):
raise Exception('Mask size must not be greater than video length')
new_vid = ref_video[0:0]
for frame_i in range(len(ref_video) - mask_size + 1):
new_frame = []
frame_range = ref_video.frames[frame_i:frame_i + mask_size]
for joint in range(ref_video.get_num_joints()):
x_med = np.median([frame[joint][0] for frame in frame_range])
y_med = np.median([frame[joint][1] for frame in frame_range])
z_med = np.median([frame[joint][2] for frame in frame_range])
new_frame.append(np.array((x_med, y_med, z_med)))
new_vid.add_frame(new_frame)
return new_vid
def conv(ref_video, mask):
if len(mask) % 2 != 1 or len(mask) < 0:
raise Exception('Mask size must be positive and odd')
if len(mask) > len(ref_video):
raise Exception('Mask size must not be greater than video length')
x_per_joint = []
y_per_joint = []
z_per_joint = []
x_per_joint_filtered = []
y_per_joint_filtered = []
z_per_joint_filtered = []
new_vid = ref_video[0:0]
for frame in ref_video.frames:
for i, joint in enumerate(frame):
if i >= len(x_per_joint):
x_per_joint.append([])
y_per_joint.append([])
z_per_joint.append([])
x_per_joint[i].append(joint[0])
y_per_joint[i].append(joint[1])
z_per_joint[i].append(joint[2])
for joint_num in range(ref_video.get_num_joints()):
x_per_joint_filtered.append(np.convolve(x_per_joint[joint_num], mask, 'valid'))
y_per_joint_filtered.append(np.convolve(y_per_joint[joint_num], mask, 'valid'))
z_per_joint_filtered.append(np.convolve(z_per_joint[joint_num], mask, 'valid'))
new_num_frames = len(x_per_joint_filtered[0])
for i in range(new_num_frames):
frame = []
for joint_num in range(ref_video.get_num_joints()):
joint_at_frame = np.array((x_per_joint_filtered[joint_num][i], y_per_joint_filtered[joint_num][i], z_per_joint_filtered[joint_num][i]))
frame.append(joint_at_frame)
new_vid.add_frame(frame)
return new_vid
def get_gaussian_value_at(std, mean, x):
a = 1 / (2 * math.pi * (std ** 2)) ** 0.5
b = ((-1) * (x - mean) ** 2) / (2 * (std ** 2))
return a * (math.e ** b)
def generate_gaussian_mask(std, length):
if length % 2 == 0:
raise Exception('Mask size must be odd')
mask_center_idx = int(length / 2) # Counting indices from 0 :)
mask = []
for i in range(length):
at_std = abs(mask_center_idx - i)
mask.append(get_gaussian_value_at(std, 0, at_std))
#current_norm = np.linalg.norm(mask)
#factor = 1.0 / current_norm
mask_sum = np.sum(mask)
factor = 1.0 / mask_sum
return [factor * val for val in mask]
def gaussian_filter(ref_vid, mask_size, std):
mask = generate_gaussian_mask(std, mask_size)
return conv(ref_vid, mask)
def to_vector(ref_video):
num_vals = len(ref_video) * ref_video.get_num_joints() * 3
vec = np.zeros(num_vals)
offset = 0
for frame in ref_video.frames:
for joint in frame:
vec[offset:offset + 3] = joint
offset += 3
return vec
def compress(ref_video):
new_vid = ref_video[:]
for joint in range(new_vid.get_num_joints()):
for dim in range(3):
vals = [frame[joint][dim] for frame in new_vid.frames]
std = np.std(vals)
min_detail_level = std / len(vals)
num_decimal_points = int(- (round(np.log10(min_detail_level)) - 1))
num_decimal_points = 0 if num_decimal_points < 0 else num_decimal_points
for frame in new_vid.frames:
frame[joint][dim] = round(frame[joint][dim], num_decimal_points)
return new_vid
class SkvpPyramid:
def __init__(self, skvp_video, filter_sizes, filter_stds):
self.original_video = skvp_video[:]
self.levels = []
if len(filter_sizes) != len(filter_stds):
raise SkvpVideoInvalidInitError('"filter sizes" and "filter stds" must have the same lengths')
self.filter_sizes = list(filter_sizes)
self.filter_stds = list(filter_stds)
self._create_pyramid()
def get_num_levels(self):
return len(self.levels)
def get_level(self, level):
return self.levels[level]
def _create_pyramid(self):
self.levels.append(self.original_video)
for f_size, f_std in zip(self.filter_sizes, self.filter_stds):
ref_vid = self.levels[-1]
ref_vid_blurred = gaussian_filter(ref_vid, f_size, f_std)
next_vid = create_length_scaled_video(ref_vid_blurred, num_frames = int(len(ref_vid) / 2))
self.levels.append(next_vid)
def map_index(self, index, orig_level, dst_level):
if orig_level < 0 or orig_level >= len(self.levels):
raise SkvpVideoInvalidValueError('"orig level" is out of range')
if dst_level < 0 or dst_level >= len(self.levels):
raise SkvpVideoInvalidValueError('"dst level" is out of range')
if index < 0 or index >= len(self.levels[orig_level]):
raise SkvpVideoInvalidValueError('Index {0} is out of range for level {1}'.format(str(index), str(orig_level)))
direction = 1 if (dst_level - orig_level > 0) else -1
new_index = index
for i in range(orig_level, dst_level, direction):
if direction == 1:
new_index = self._map_adjacent(new_index, i, i + 1, True)
else:
new_index = self._map_adjacent(new_index, i - 1, i)
return new_index
def _map_adjacent(self, index, parent_level, child_level, parent_to_child = False):
offset = int(self.filter_sizes[parent_level] / 2)
parent_vid_size = len(self.levels[parent_level]) - 2 * offset
child_vid_size = len(self.levels[child_level])
if parent_to_child:
if index - offset < 0 or index + offset >= parent_vid_size:
raise SkvpForbiddenOperationError('Cannot map index {0} from level {1} to level {2} because it was clipped out by the filter'.format(str(index), str(parent_level), str(child_level)))
return int(round(child_vid_size * ((index - offset) / parent_vid_size)))
return int(round(parent_vid_size * (index / child_vid_size) + offset))
def pyramid(ref_vid, filter_sizes, filter_stds):
return SkvpPyramid(ref_vid, filter_sizes, filter_stds)
def pyramid_old(ref_vid, max_depth = None, min_length = 3):
ret_pyr = [ref_vid[:]]
curr_len = len(ret_pyr[-1])
if curr_len <= min_length:
return ret_pyr
if max_depth != None and len(ret_pyr) > max_depth:
return ret_pyr
while True:
if len(ret_pyr) > max_depth:
return ret_pyr
curr_len = len(ret_pyr[-1])
next_len = int(curr_len / 2.0)
if next_len < min_length:
return ret_pyr
last_vid_blurred = gaussian_filter(ret_pyr[-1], 3, 1)
ret_pyr.append(create_length_scaled_video(last_vid_blurred, num_frames = next_len))
def project_to_body_plane(ref_vid, spine_base_index, shoulder_left_index, shoulder_right_index):
ret_vid = ref_vid[0:0]
for i, frame in enumerate(ref_vid.frames):
shoulder_center = 0.5 * (frame[shoulder_left_index] + frame[shoulder_right_index])
y_axis = shoulder_center - frame[spine_base_index]
y_axis /= | np.linalg.norm(y_axis) | numpy.linalg.norm |
#!/usr/bin/env python
__copyright__ = """
Copyright (c) 2020 <NAME>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions: The above copyright notice and this permission
notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
"""
import numpy as np
import tensorflow as tf
def rot_z(t):
""" Rotation about the z-axis. """
c = np.cos(t)
s = np.sin(t)
ones = np.ones_like(c)
zeros = np.zeros_like(c)
return np.asarray([[c, -s, zeros], [s, c, zeros], [zeros, zeros, ones]])
def make_eight_points_boxes(bboxes_xyzlwhy):
bboxes_xyzlwhy = np.asarray(bboxes_xyzlwhy)
l = bboxes_xyzlwhy[:, 3] / 2.0
w = bboxes_xyzlwhy[:, 4] / 2.0
h = bboxes_xyzlwhy[:, 5] / 2.0
# 3d bounding box corners
x_corners = np.asarray([l, l, -l, -l, l, l, -l, -l])
y_corners = np.asarray([w, -w, -w, w, w, -w, -w, w])
z_corners = np.asarray([-h, -h, -h, -h, h, h, h, h])
corners_3d = np.concatenate(([x_corners], [y_corners], [z_corners]), axis=0)
yaw = | np.asarray(bboxes_xyzlwhy[:, -1], dtype=np.float) | numpy.asarray |
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
all
from viabel import all_bounds
from viabel.vb import black_box_klvi, black_box_chivi, adagrad_optimize
from utils import Timer
from psis import psislw
## Display bounds information ##
def print_bounds(results):
print('Bounds on...')
print(' 2-Wasserstein {:.3g}'.format(results['W2']))
print(' 2-divergence {:.3g}'.format(results['d2']))
print(' mean error {:.3g}'.format(results['mean_error']))
print(' stdev error {:.3g}'.format(results['std_error']))
print(' sqrt cov error {:.3g}'.format(np.sqrt(results['cov_error'])))
print(' cov error {:.3g}'.format(results['cov_error']))
## Check approximation accuracy ##
def check_accuracy(true_mean, true_cov, approx_mean, approx_cov, verbose=False,
method=None):
true_std = np.sqrt(np.diag(true_cov))
approx_std = np.sqrt(np.diag(approx_cov))
results = dict(mean_error=np.linalg.norm(true_mean - approx_mean),
cov_error_2=np.linalg.norm(true_cov - approx_cov, ord=2),
cov_norm_2=np.linalg.norm(true_cov, ord=2),
cov_error_nuc=np.linalg.norm(true_cov - approx_cov, ord='nuc'),
cov_norm_nuc=np.linalg.norm(true_cov, ord='nuc'),
std_error=np.linalg.norm(true_std - approx_std),
rel_std_error=np.linalg.norm(approx_std/true_std - 1),
)
if method is not None:
results['method'] = method
if verbose:
print('mean =', approx_mean)
print('stdevs =', approx_std)
print()
print('mean error = {:.3g}'.format(results['mean_error']))
print('stdev error = {:.3g}'.format(results['std_error']))
print('||cov error||_2^{{1/2}} = {:.3g}'.format(np.sqrt(results['cov_error_2'])))
print('||true cov||_2^{{1/2}} = {:.3g}'.format(np.sqrt(results['cov_norm_2'])))
return results
def check_approx_accuracy(var_family, var_param, true_mean, true_cov,
verbose=False, name=None):
return check_accuracy(true_mean, true_cov,
*var_family.mean_and_cov(var_param),
verbose, name)
## Convenience functions and PSIS ##
def get_samples_and_log_weights(logdensity, var_family, var_param, n_samples):
samples = var_family.sample(var_param, n_samples)
log_weights = logdensity(samples) - var_family.logdensity(samples, var_param)
return samples, log_weights
def psis_correction(logdensity, var_family, var_param, n_samples):
samples, log_weights = get_samples_and_log_weights(logdensity, var_family,
var_param, n_samples)
smoothed_log_weights, khat = psislw(log_weights)
return samples.T, smoothed_log_weights, khat
def improve_with_psis(logdensity, var_family, var_param, n_samples,
true_mean, true_cov, transform=None, verbose=False):
samples, slw, khat = psis_correction(logdensity, var_family,
var_param, n_samples)
if verbose:
print('khat = {:.3g}'.format(khat))
print()
if transform is not None:
samples = transform(samples)
slw -= np.max(slw)
wts = np.exp(slw)
wts /= np.sum(wts)
approx_mean = np.sum(wts[np.newaxis,:]*samples, axis=1)
approx_cov = np.cov(samples, aweights=wts, ddof=0)
res = check_accuracy(true_mean, true_cov, approx_mean, approx_cov, verbose)
res['khat'] = khat
return res, approx_mean, approx_cov
## Plotting ##
def plot_approx_and_exact_contours(logdensity, var_family, var_param,
xlim=[-10,10], ylim=[-3, 3],
cmap2='Reds', savepath=None):
xlist = | np.linspace(*xlim, 100) | numpy.linspace |
import numpy as np
import math
w1 = np.array([
[-1],
[-1],
], dtype=float)
w2 = np.array([
[0],
[0],
], dtype=float)
w3 = np.array([
[1],
[1],
], dtype=float)
# 初始化 预处理
C = 1
m, n = w1.shape
w = np.zeros((m + 1, 3))
print("Initial:\n", w)
add_row = | np.ones(n) | numpy.ones |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import numpy as np
import os
import sys
import random
GEOSCORER_DIR = os.path.dirname(os.path.realpath(__file__))
CRAFTASSIST_DIR = os.path.join(GEOSCORER_DIR, "../../")
sys.path.append(CRAFTASSIST_DIR)
import shapes
import shape_helpers as sh
import torch
import torch.utils.data
from geoscorer_util import *
# subshapes by everything in a l1 or l2 ball from a point.
# put pairs + triples of shapes in frame, sometimes one partially built
PERM = torch.randperm(256)
r = np.arange(0, 256) / 256
CMAP = np.stack((r, np.roll(r, 80), np.roll(r, 160)))
SMALL = 5
LARGE = 20
def get_shape(name="random", opts=None):
if name != "random" and name not in SHAPENAMES:
pretty_log("Shape name {} not in dict, choosing randomly".format(name))
name = "random"
if name == "random":
name = random.choice(SHAPENAMES)
if not opts:
opts = SHAPE_HELPERS[name]()
opts["labelme"] = False
return SHAPEFNS[name](**opts), opts, name
def options_cube():
return {"size": np.random.randint(SMALL, LARGE)}
def options_hollow_cube():
opts = {}
opts["size"] = np.random.randint(SMALL, LARGE)
opts["thickness"] = np.random.randint(1, opts["size"] - 3)
return opts
def options_rectanguloid():
return {"size": np.random.randint(SMALL, LARGE, size=3)}
def options_hollow_rectanguloid():
opts = {}
opts["size"] = np.random.randint(SMALL, LARGE, size=3)
ms = min(opts["size"])
opts["thickness"] = np.random.randint(1, ms - 3)
return opts
def options_sphere():
return {"radius": np.random.randint(SMALL, LARGE)}
def options_spherical_shell():
opts = {}
opts["radius"] = np.random.randint(SMALL, LARGE)
opts["thickness"] = np.random.randint(1, opts["radius"] - 3)
return opts
def options_square_pyramid():
opts = {}
opts["radius"] = np.random.randint(SMALL, LARGE)
opts["slope"] = np.random.rand() * 0.4 + 0.8
fullheight = opts["radius"] * opts["slope"]
opts["height"] = np.random.randint(0.5 * fullheight, fullheight)
return opts
def options_square():
return {"size": np.random.randint(SMALL, LARGE), "orient": sh.orientation3()}
def options_rectangle():
return {"size": np.random.randint(SMALL, LARGE, size=2), "orient": sh.orientation3()}
def options_circle():
return {"radius": np.random.randint(SMALL, LARGE), "orient": sh.orientation3()}
def options_disk():
return {"radius": np.random.randint(SMALL, LARGE), "orient": sh.orientation3()}
def options_triangle():
return {"size": np.random.randint(SMALL, LARGE), "orient": sh.orientation3()}
def options_dome():
return {"radius": np.random.randint(SMALL, LARGE)}
def options_arch():
return {"size": np.random.randint(SMALL, LARGE), "distance": 2 * np.random.randint(2, 5) + 1}
def options_ellipsoid():
return {"size": np.random.randint(SMALL, LARGE, size=3)}
def options_tower():
return {"height": | np.random.randint(3, 30) | numpy.random.randint |
"""
.. module:: VisMPL
:platform: Unix, Windows
:synopsis: Matplotlib visualization component for NURBS-Python
.. moduleauthor:: <NAME> <<EMAIL>>
"""
from geomdl import vis
import numpy as np
import matplotlib as mpl
import matplotlib.tri as mpltri
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
from matplotlib import animation
class VisConfig(vis.VisConfigAbstract):
""" Configuration class for Matplotlib visualization module.
This class is only required when you would like to change the visual defaults of the plots and the figure,
such as hiding control points plot or legend.
The ``VisMPL`` module has the following configuration variables:
* ``ctrlpts`` (bool): Control points polygon/grid visibility. *Default: True*
* ``evalpts`` (bool): Curve/surface points visibility. *Default: True*
* ``bbox`` (bool): Bounding box visibility. *Default: False*
* ``legend`` (bool): Figure legend visibility. *Default: True*
* ``axes`` (bool): Axes and figure grid visibility. *Default: True*
* ``labels`` (bool): Axis labels visibility. *Default: True*
* ``trims`` (bool): Trim curves visibility. *Default: True*
* ``axes_equal`` (bool): Enables or disables equal aspect ratio for the axes. *Default: True*
* ``figure_size`` (list): Size of the figure in (x, y). *Default: [10, 8]*
* ``figure_dpi`` (int): Resolution of the figure in DPI. *Default: 96*
* ``trim_size`` (int): Size of the trim curves. *Default: 20*
* ``alpha`` (float): Opacity of the evaluated points. *Default: 1.0*
There is also a ``debug`` configuration variable which currently adds quiver plots to 2-dimensional curves to show
their directions.
The following example illustrates the usage of the configuration class.
.. code-block:: python
:linenos:
# Create a curve (or a surface) instance
curve = NURBS.Curve()
# Skipping degree, knot vector and control points assignments
# Create a visualization configuration instance with no legend, no axes and set the resolution to 120 dpi
vis_config = VisMPL.VisConfig(legend=False, axes=False, figure_dpi=120)
# Create a visualization method instance using the configuration above
vis_obj = VisMPL.VisCurve2D(vis_config)
# Set the visualization method of the curve object
curve.vis = vis_obj
# Plot the curve
curve.render()
Please refer to the **Examples Repository** for more details.
"""
def __init__(self, **kwargs):
super(VisConfig, self).__init__(**kwargs)
self.dtype = np.float
self.display_ctrlpts = kwargs.get('ctrlpts', True)
self.display_evalpts = kwargs.get('evalpts', True)
self.display_bbox = kwargs.get('bbox', False)
self.display_legend = kwargs.get('legend', True)
self.display_axes = kwargs.get('axes', True)
self.display_labels = kwargs.get('labels', True)
self.display_trims = kwargs.get('trims', True)
self.axes_equal = kwargs.get('axes_equal', True)
self.figure_size = kwargs.get('figure_size', [10, 8])
self.figure_dpi = kwargs.get('figure_dpi', 96)
self.trim_size = kwargs.get('trim_size', 20)
self.alpha = kwargs.get('alpha', 1.0)
self.figure_image_filename = "temp-figure.png"
self.debug_mode = kwargs.get('debug', False) # debugging mode for determining the trim directions
@staticmethod
def set_axes_equal(ax):
""" Sets equal aspect ratio across the three axes of a 3D plot.
Contributed by <NAME>.
:param ax: a Matplotlib axis, e.g., as output from plt.gca().
"""
bounds = [ax.get_xlim3d(), ax.get_ylim3d(), ax.get_zlim3d()]
ranges = [abs(bound[1] - bound[0]) for bound in bounds]
centers = [np.mean(bound) for bound in bounds]
radius = 0.5 * max(ranges)
lower_limits = centers - radius
upper_limits = centers + radius
ax.set_xlim3d([lower_limits[0], upper_limits[0]])
ax.set_ylim3d([lower_limits[1], upper_limits[1]])
ax.set_zlim3d([lower_limits[2], upper_limits[2]])
@staticmethod
def save_figure_as(fig, filename):
""" Saves the figure as a file.
:param fig: a Matplotlib figure instance
:param filename: file name to save
"""
if filename is not None:
fig.savefig(str(filename), bbox_inches='tight')
def is_notebook(self):
""" Detects if Jupyter notebook GUI toolkit is active
return: True if the module is running inside a Jupyter notebook
rtype: bool
"""
return True if "nbAgg" == mpl.get_backend() else False
class VisCurve2D(vis.VisAbstract):
""" Matplotlib visualization module for 2D curves """
def __init__(self, config=VisConfig(), **kwargs):
super(VisCurve2D, self).__init__(config, **kwargs)
def render(self, **kwargs):
""" Plots the 2D curve and the control points polygon. """
# Calling parent function
super(VisCurve2D, self).render(**kwargs)
# Initialize variables
legend_proxy = []
legend_names = []
# Draw control points polygon and the curve
fig = plt.figure(figsize=self.vconf.figure_size, dpi=self.vconf.figure_dpi)
ax = fig.gca()
# Start plotting
for plot in self._plots:
pts = np.array(plot['ptsarr'], dtype=self.vconf.dtype)
# Plot control points
if plot['type'] == 'ctrlpts' and self.vconf.display_ctrlpts:
cpplot, = plt.plot(pts[:, 0], pts[:, 1], color=plot['color'], linestyle='-.', marker='o')
legend_proxy.append(cpplot)
legend_names.append(plot['name'])
# Plot evaluated points
if plot['type'] == 'evalpts' and self.vconf.display_evalpts:
curveplt, = plt.plot(pts[:, 0], pts[:, 1], color=plot['color'], linestyle='-', alpha=self.vconf.alpha)
legend_proxy.append(curveplt)
legend_names.append(plot['name'])
# Debugging for curve directions
if self.vconf.debug_mode:
plt.quiver(pts[0, 0], pts[0, 1], pts[-1, 0] - pts[0, 0], pts[-1, 1] - pts[0, 1],
color='k', angles='xy', scale_units='xy', scale=1, width=0.003)
# Plot bounding box
if plot['type'] == 'bbox' and self.vconf.display_bbox:
bboxplt, = plt.plot(pts[:, 0], pts[:, 1], color=plot['color'], linestyle='--')
legend_proxy.append(bboxplt)
legend_names.append(plot['name'])
# Plot extras
if plot['type'] == 'extras':
extrasplt, = plt.plot(pts[:, 0], pts[:, 1],
color=plot['color'][0], linestyle='-', linewidth=plot['color'][1])
legend_proxy.append(extrasplt)
legend_names.append(plot['name'])
# Add legend
if self.vconf.display_legend:
plt.legend(legend_proxy, legend_names)
# Remove axes
if not self.vconf.display_axes:
plt.axis('off')
# Set aspect ratio
if self.vconf.axes_equal:
ax.set_aspect('equal')
# Axis labels
if self.vconf.display_labels:
ax.set_xlabel('x')
ax.set_ylabel('y')
# Process keyword arguments
fig_filename = kwargs.get('fig_save_as', None)
fig_display = kwargs.get('display_plot', True)
# Check if running inside a Jupyter notebook
if not self.vconf.is_notebook():
# Display the plot or save the figure
if fig_display:
plt.show()
else:
fig_filename = self.vconf.figure_image_filename if fig_filename is None else fig_filename
self.vconf.save_figure_as(fig, fig_filename)
class VisCurve3D(vis.VisAbstract):
""" Matplotlib visualization module for 3D curves. """
def __init__(self, config=VisConfig(), **kwargs):
super(VisCurve3D, self).__init__(config, **kwargs)
def render(self, **kwargs):
""" Plots the 3D curve and the control points polygon. """
# Calling parent function
super(VisCurve3D, self).render(**kwargs)
# Initialize variables
legend_proxy = []
legend_names = []
# Draw control points polygon and the 3D curve
fig = plt.figure(figsize=self.vconf.figure_size, dpi=self.vconf.figure_dpi)
ax = Axes3D(fig)
# Start plotting
for plot in self._plots:
pts = np.array(plot['ptsarr'], dtype=self.vconf.dtype)
# Try not to fail if the input is 2D
if pts.shape[1] == 2:
pts = np.c_[pts, np.zeros(pts.shape[0])]
# Plot control points
if plot['type'] == 'ctrlpts' and self.vconf.display_ctrlpts:
ax.plot(pts[:, 0], pts[:, 1], pts[:, 2], color=plot['color'], linestyle='-.', marker='o')
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='-.', color=plot['color'], marker='o')
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Plot evaluated points
if plot['type'] == 'evalpts' and self.vconf.display_evalpts:
ax.plot(pts[:, 0], pts[:, 1], pts[:, 2], color=plot['color'], linestyle='-', alpha=self.vconf.alpha)
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='-', color=plot['color'])
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Plot bounding box
if plot['type'] == 'bbox' and self.vconf.display_bbox:
ax.plot(pts[:, 0], pts[:, 1], pts[:, 2], color=plot['color'], linestyle='--')
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='--', color=plot['color'])
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Plot extras
if plot['type'] == 'extras':
ax.plot(pts[:, 0], pts[:, 1], pts[:, 2],
color=plot['color'][0], linestyle='-', linewidth=plot['color'][1])
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='-', color=plot['color'][0])
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Add legend to 3D plot, @ref: https://stackoverflow.com/a/20505720
if self.vconf.display_legend:
ax.legend(legend_proxy, legend_names, numpoints=1)
# Remove axes
if not self.vconf.display_axes:
plt.axis('off')
# Set axes equal
if self.vconf.axes_equal:
self.vconf.set_axes_equal(ax)
# Axis labels
if self.vconf.display_labels:
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
# Process keyword arguments
fig_filename = kwargs.get('fig_save_as', None)
fig_display = kwargs.get('display_plot', True)
# Check if running inside a Jupyter notebook
if not self.vconf.is_notebook():
# Display the plot or save the figure
if fig_display:
plt.show()
else:
fig_filename = self.vconf.figure_image_filename if fig_filename is None else fig_filename
self.vconf.save_figure_as(fig, fig_filename)
class VisSurface(vis.VisAbstract):
""" Matplotlib visualization module for surfaces.
Wireframe plot for the control points and triangulated plot (using ``plot_trisurf``) for the surface points.
The surface is triangulated externally using :py:func:`.utilities.make_triangle_mesh()` function.
"""
def __init__(self, config=VisConfig(), **kwargs):
super(VisSurface, self).__init__(config, **kwargs)
self._module_config['ctrlpts'] = "quads"
self._module_config['evalpts'] = "triangles"
def animate(self, **kwargs):
""" Animates the surface.
This function only animates the triangulated surface. There will be no other elements, such as control points
grid or bounding box.
Keyword arguments:
* ``colormap``: applies colormap to the surface
Colormaps are a visualization feature of Matplotlib. They can be used for several types of surface plots via
the following import statement: ``from matplotlib import cm``
The following link displays the list of Matplolib colormaps and some examples on colormaps:
https://matplotlib.org/tutorials/colors/colormaps.html
"""
# Calling parent render function
super(VisSurface, self).render(**kwargs)
# Colormaps
surf_cmaps = kwargs.get('colormap', None)
# Initialize variables
tri_idxs = []
vert_coords = []
trisurf_params = []
frames = []
frames_tris = []
num_vertices = 0
# Start plotting of the surface and the control points grid
fig = plt.figure(figsize=self.vconf.figure_size, dpi=self.vconf.figure_dpi)
ax = Axes3D(fig)
# Start plotting
surf_count = 0
for plot in self._plots:
# Plot evaluated points
if plot['type'] == 'evalpts' and self.vconf.display_evalpts:
# Use internal triangulation algorithm instead of Qhull (MPL default)
verts = plot['ptsarr'][0]
tris = plot['ptsarr'][1]
# Extract zero-indexed vertex number list
tri_idxs += [[ti + num_vertices for ti in tri.data] for tri in tris]
# Extract vertex coordinates
vert_coords += [vert.data for vert in verts]
# Update number of vertices
num_vertices = len(vert_coords)
# Determine the color or the colormap of the triangulated plot
params = {}
if surf_cmaps:
try:
params['cmap'] = surf_cmaps[surf_count]
surf_count += 1
except IndexError:
params['color'] = plot['color']
else:
params['color'] = plot['color']
trisurf_params += [params for _ in range(len(tris))]
# Pre-processing for the animation
pts = np.array(vert_coords, dtype=self.vconf.dtype)
# Create the frames (Artists)
for tidx, pidx in zip(tri_idxs, trisurf_params):
frames_tris.append(tidx)
# Create MPL Triangulation object
triangulation = mpltri.Triangulation(pts[:, 0], pts[:, 1], triangles=frames_tris)
# Use custom Triangulation object and the choice of color/colormap to plot the surface
p3df = ax.plot_trisurf(triangulation, pts[:, 2], alpha=self.vconf.alpha, **pidx)
# Add to frames list
frames.append([p3df])
# Create MPL ArtistAnimation
ani = animation.ArtistAnimation(fig, frames, interval=100, blit=True, repeat_delay=1000)
# Remove axes
if not self.vconf.display_axes:
plt.axis('off')
# Set axes equal
if self.vconf.axes_equal:
self.vconf.set_axes_equal(ax)
# Axis labels
if self.vconf.display_labels:
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
# Process keyword arguments
fig_filename = kwargs.get('fig_save_as', None)
fig_display = kwargs.get('display_plot', True)
# Check if running inside a Jupyter notebook
if not self.vconf.is_notebook():
# Display the plot or save the figure
if fig_display:
plt.show()
else:
fig_filename = self.vconf.figure_image_filename if fig_filename is None else fig_filename
self.vconf.save_figure_as(fig, fig_filename)
def render(self, **kwargs):
""" Plots the surface and the control points grid.
Keyword arguments:
* ``colormap``: applies colormap to the surface
Colormaps are a visualization feature of Matplotlib. They can be used for several types of surface plots via
the following import statement: ``from matplotlib import cm``
The following link displays the list of Matplolib colormaps and some examples on colormaps:
https://matplotlib.org/tutorials/colors/colormaps.html
"""
# Calling parent function
super(VisSurface, self).render(**kwargs)
# Colormaps
surf_cmaps = kwargs.get('colormap', None)
# Initialize variables
legend_proxy = []
legend_names = []
# Start plotting of the surface and the control points grid
fig = plt.figure(figsize=self.vconf.figure_size, dpi=self.vconf.figure_dpi)
ax = Axes3D(fig)
surf_count = 0
# Start plotting
for plot in self._plots:
# Plot control points
if plot['type'] == 'ctrlpts' and self.vconf.display_ctrlpts:
vertices = [v.data for v in plot['ptsarr'][0]]
faces = [q.data for q in plot['ptsarr'][1]]
for q in faces:
el = np.array([vertices[i] for i in q], dtype=self.vconf.dtype)
el[:, 2] += self._ctrlpts_offset
pc3d = Poly3DCollection([el], alpha=0.0, edgecolors=plot['color'], linewidths=1.0, linestyles='-.')
pc3d.set_facecolor(None)
ax.add_collection3d(pc3d)
pts = np.array(vertices, dtype=self.vconf.dtype)
pts[:, 2] += self._ctrlpts_offset
ax.scatter(pts[:, 0], pts[:, 1], pts[:, 2], color=plot['color'], linestyle='-.', marker='o')
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='-.', color=plot['color'], marker='o')
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Plot evaluated points
if plot['type'] == 'evalpts' and self.vconf.display_evalpts:
# Use internal triangulation algorithm instead of Qhull (MPL default)
verts = plot['ptsarr'][0]
tris = plot['ptsarr'][1]
# Extract zero-indexed vertex number list
tri_idxs = [tri.data for tri in tris]
# Extract vertex coordinates
vert_coords = [vert.data for vert in verts]
pts = np.array(vert_coords, dtype=self.vconf.dtype)
# Determine the color or the colormap of the triangulated plot
trisurf_params = {}
if surf_cmaps:
try:
trisurf_params['cmap'] = surf_cmaps[surf_count]
surf_count += 1
except IndexError:
trisurf_params['color'] = plot['color']
else:
trisurf_params['color'] = plot['color']
# Create MPL Triangulation object
if pts.size != 0:
triangulation = mpltri.Triangulation(pts[:, 0], pts[:, 1], triangles=tri_idxs)
# Use custom Triangulation object and the choice of color/colormap to plot the surface
ax.plot_trisurf(triangulation, pts[:, 2], alpha=self.vconf.alpha, **trisurf_params)
# Add to legend
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='none', color=plot['color'], marker='^')
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Plot bounding box
if plot['type'] == 'bbox' and self.vconf.display_bbox:
pts = np.array(plot['ptsarr'], dtype=self.vconf.dtype)
ax.plot(pts[:, 0], pts[:, 1], pts[:, 2], color=plot['color'], linestyle='--')
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='--', color=plot['color'])
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Plot trim curves
if self.vconf.display_trims:
if plot['type'] == 'trimcurve':
pts = np.array(plot['ptsarr'], dtype=self.vconf.dtype)
ax.scatter(pts[:, 0], pts[:, 1], pts[:, 2], color=plot['color'], marker='o',
s=self.vconf.trim_size, depthshade=False)
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='none', color=plot['color'], marker='o')
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Plot extras
if plot['type'] == 'extras':
pts = np.array(plot['ptsarr'], dtype=self.vconf.dtype)
ax.plot(pts[:, 0], pts[:, 1], pts[:, 2],
color=plot['color'][0], linestyle='-', linewidth=plot['color'][1])
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='-', color=plot['color'][0])
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Add legend to 3D plot, @ref: https://stackoverflow.com/a/20505720
if self.vconf.display_legend:
ax.legend(legend_proxy, legend_names, numpoints=1)
# Remove axes
if not self.vconf.display_axes:
plt.axis('off')
# Set axes equal
if self.vconf.axes_equal:
self.vconf.set_axes_equal(ax)
# Axis labels
if self.vconf.display_labels:
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
# Process keyword arguments
fig_filename = kwargs.get('fig_save_as', None)
fig_display = kwargs.get('display_plot', True)
# Check if running inside a Jupyter notebook
if not self.vconf.is_notebook():
# Display the plot or save the figure
if fig_display:
plt.show()
else:
fig_filename = self.vconf.figure_image_filename if fig_filename is None else fig_filename
self.vconf.save_figure_as(fig, fig_filename)
class VisSurfWireframe(vis.VisAbstract):
""" Matplotlib visualization module for surfaces.
Scatter plot for the control points and wireframe plot for the surface points.
"""
def __init__(self, config=VisConfig(), **kwargs):
super(VisSurfWireframe, self).__init__(config, **kwargs)
self._module_config['ctrlpts'] = "points"
self._module_config['evalpts'] = "quads"
def render(self, **kwargs):
""" Plots the surface and the control points grid. """
# Calling parent function
super(VisSurfWireframe, self).render(**kwargs)
# Initialize variables
legend_proxy = []
legend_names = []
# Start plotting of the surface and the control points grid
fig = plt.figure(figsize=self.vconf.figure_size, dpi=self.vconf.figure_dpi)
ax = Axes3D(fig)
# Start plotting
for plot in self._plots:
# Plot control points
if plot['type'] == 'ctrlpts' and self.vconf.display_ctrlpts:
pts = np.array(plot['ptsarr'], dtype=self.vconf.dtype)
cp_z = pts[:, 2] + self._ctrlpts_offset
ax.scatter(pts[:, 0], pts[:, 1], cp_z, color=plot['color'], s=25, depthshade=True)
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='-.', color=plot['color'], marker='o')
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Plot evaluated points
if plot['type'] == 'evalpts' and self.vconf.display_evalpts:
vertices = [v.data for v in plot['ptsarr'][0]]
faces = [q.data for q in plot['ptsarr'][1]]
for q in faces:
el = np.array([vertices[i] for i in q], dtype=self.vconf.dtype)
el[:, 2] += self._ctrlpts_offset
pc3d = Poly3DCollection([el], alpha=0.0, edgecolors=plot['color'], linewidths=0.5, linestyles='-')
pc3d.set_facecolor(None)
ax.add_collection3d(pc3d)
pts = np.array(vertices, dtype=self.vconf.dtype)
ax.scatter(pts[:, 0], pts[:, 1], pts[:, 2], color=plot['color'], s=5)
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='-', color=plot['color'])
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Plot bounding box
if plot['type'] == 'bbox' and self.vconf.display_bbox:
pts = np.array(plot['ptsarr'], dtype=self.vconf.dtype)
ax.plot(pts[:, 0], pts[:, 1], pts[:, 2], color=plot['color'], linestyle='--')
plot_proxy = mpl.lines.Line2D([0], [0], linestyle='--', color=plot['color'])
legend_proxy.append(plot_proxy)
legend_names.append(plot['name'])
# Plot trim curves
if self.vconf.display_trims:
if plot['type'] == 'trimcurve':
pts = | np.array(plot['ptsarr'], dtype=self.vconf.dtype) | numpy.array |
# pylint: disable=R0201
import os
import numpy as np
import pytest
from PartSegImage import Image, ImageWriter, TiffImageReader
from PartSegImage.image import FRAME_THICKNESS
class TestImageBase:
image_class = Image
def needed_shape(self, shape, axes: str, drop: str):
new_axes = self.image_class.axis_order
for el in drop:
new_axes = new_axes.replace(el, "")
res_shape = [1] * len(new_axes)
for size, name in zip(shape, axes):
res_shape[new_axes.index(name)] = size
return tuple(res_shape)
def image_shape(self, shape, axes):
return self.needed_shape(shape, axes, "")
def mask_shape(self, shape, axes):
return self.needed_shape(shape, axes, "C")
def reorder_axes_letter(self, letters: str):
res = "".join(x for x in self.image_class.axis_order if x in letters)
assert len(res) == len(letters)
return res
def prepare_mask_shape(self, shape):
base_axes = set("TZYX")
refer_axes = self.image_class.axis_order.replace("C", "")
i, j = 0, 0
new_shape = [1] * len(refer_axes)
for i, val in enumerate(refer_axes):
if val in base_axes:
new_shape[i] = shape[j]
j += 1
return new_shape
def prepare_image_initial_shape(self, shape, channel):
new_shape = self.prepare_mask_shape(shape)
new_shape.insert(self.image_class.axis_order.index("C"), channel)
return new_shape
def test_fit_mask_simple(self):
initial_shape = self.prepare_image_initial_shape([1, 10, 20, 20], 1)
data = np.zeros(initial_shape, np.uint8)
image = self.image_class(data, (1, 1, 1), "")
mask = np.zeros((1, 10, 20, 20), np.uint8)
mask[0, 2:-2, 4:-4, 4:-4] = 5
image.fit_mask_to_image(mask)
def test_fit_mask_mapping_val(self):
initial_shape = self.prepare_image_initial_shape([1, 10, 20, 20], 1)
data = np.zeros(initial_shape, np.uint8)
image = self.image_class(data, (1, 1, 1), "")
mask = np.zeros((1, 10, 20, 20), np.uint16)
mask[0, 2:-2, 4:-4, 4:10] = 5
mask[0, 2:-2, 4:-4, 11:-4] = 7
mask2 = image.fit_mask_to_image(mask)
assert np.all(np.unique(mask2) == [0, 1, 2])
assert np.all(np.unique(mask) == [0, 5, 7])
map_arr = np.array([0, 0, 0, 0, 0, 1, 0, 2])
assert np.all(map_arr[mask] == mask2)
assert mask2.dtype == np.uint8
def test_fit_mask_to_image_change_type(self):
initial_shape = self.prepare_image_initial_shape([1, 30, 50, 50], 1)
data = np.zeros(initial_shape, np.uint8)
image = self.image_class(data, (1, 1, 1), "")
mask_base = np.zeros(30 * 50 * 50, dtype=np.uint32)
mask_base[:50] = np.arange(50, dtype=np.uint32)
image.set_mask(np.reshape(mask_base, (1, 30, 50, 50)))
assert image.mask.dtype == np.uint8
mask_base[:50] = np.arange(50, dtype=np.uint32) + 5
image.set_mask(np.reshape(mask_base, (1, 30, 50, 50)))
assert image.mask.dtype == np.uint8
mask_base[:350] = np.arange(350, dtype=np.uint32)
image.set_mask(np.reshape(mask_base, (1, 30, 50, 50)))
assert image.mask.dtype == np.uint16
mask_base[:350] = np.arange(350, dtype=np.uint32) + 5
image.set_mask(np.reshape(mask_base, (1, 30, 50, 50)))
assert image.mask.dtype == np.uint16
mask_base[: 2 ** 16 + 5] = np.arange(2 ** 16 + 5, dtype=np.uint32)
image.set_mask(np.reshape(mask_base, (1, 30, 50, 50)))
assert image.mask.dtype == np.uint32
mask_base[: 2 ** 16 + 5] = np.arange(2 ** 16 + 5, dtype=np.uint32) + 5
image.set_mask(np.reshape(mask_base, (1, 30, 50, 50)))
assert image.mask.dtype == np.uint32
def test_image_mask(self):
initial_shape = self.prepare_image_initial_shape([1, 10, 50, 50], 4)
self.image_class(np.zeros(initial_shape), (5, 5, 5), mask=np.zeros((10, 50, 50)))
self.image_class(np.zeros(initial_shape), (5, 5, 5), mask=np.zeros((1, 10, 50, 50)))
with pytest.raises(ValueError):
self.image_class(np.zeros((1, 10, 50, 50, 4)), (5, 5, 5), mask=np.zeros((1, 10, 50, 40)))
with pytest.raises(ValueError):
self.image_class(np.zeros((1, 10, 50, 50, 4)), (5, 5, 5), mask=np.zeros((1, 10, 50, 50, 4)))
mask = np.zeros((1, 10, 50, 50))
mask[0, 2:-2] = 1
im = self.image_class(np.zeros(initial_shape), (5, 5, 5), mask=mask)
assert np.all(im.mask == mask)
def test_reorder_axes(self):
fixed_array = self.image_class.reorder_axes(np.zeros((10, 20)), axes="XY")
assert fixed_array.shape == self.image_shape((10, 20), "XY")
fixed_image = self.image_class(np.zeros((10, 20)), image_spacing=(1, 1, 1), axes_order="XY")
assert fixed_image.shape == self.image_shape((10, 20), "XY")
with pytest.raises(ValueError):
Image.reorder_axes(np.zeros((10, 20)), axes="XYZ")
def test_reorder_axes_with_mask(self):
im = self.image_class(np.zeros((10, 50, 50, 4)), (5, 5, 5), mask=np.zeros((10, 50, 50)), axes_order="ZYXC")
assert im.shape == self.image_shape((10, 50, 50, 4), "ZYXC") # (1, 10, 50, 50, 4)
im = self.image_class(np.zeros((50, 10, 50, 4)), (5, 5, 5), mask=np.zeros((50, 10, 50)), axes_order="YZXC")
assert im.shape == self.image_shape((50, 10, 50, 4), "YZXC") # (1, 10, 50, 50, 4)
def test_wrong_dim_create(self):
with pytest.raises(ValueError) as exception_info:
self.image_class(np.zeros((10, 20)), (1, 1, 1), axes_order="XYZ")
assert "Data should" in str(exception_info.value)
def test_channel_pos(self):
initial_shape = self.prepare_image_initial_shape([1, 10, 20, 20], 1)
image = self.image_class(np.zeros(initial_shape), (1, 1, 1), "")
assert image.channel_pos == image.axis_order.index("C")
def test_get_dimension_number(self):
assert (
self.image_class(
np.zeros((1, 10, 20, 20, 1), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_number()
== 3
)
assert (
self.image_class(
np.zeros((1, 1, 20, 20, 1), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_number()
== 2
)
assert (
self.image_class(
np.zeros((10, 1, 20, 20, 1), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_number()
== 3
)
assert (
self.image_class(
np.zeros((1, 1, 20, 20, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_number()
== 3
)
assert (
self.image_class(
np.zeros((10, 1, 20, 20, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_number()
== 4
)
assert (
self.image_class(
np.zeros((10, 3, 20, 20, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_number()
== 5
)
def test_get_dimension_letters(self):
assert self.image_class(
np.zeros((1, 10, 20, 20, 1), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_letters() == self.reorder_axes_letter("ZYX")
assert self.image_class(
np.zeros((1, 1, 20, 20, 1), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_letters() == self.reorder_axes_letter("YX")
assert self.image_class(
np.zeros((10, 1, 20, 20, 1), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_letters() == self.reorder_axes_letter("TYX")
assert self.image_class(
np.zeros((1, 1, 20, 20, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_letters() == self.reorder_axes_letter("YXC")
assert self.image_class(
np.zeros((10, 1, 20, 20, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_letters() == self.reorder_axes_letter("TYXC")
assert self.image_class(
np.zeros((10, 3, 20, 20, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC"
).get_dimension_letters() == self.reorder_axes_letter("TZYXC")
def test_set_mask(self):
initial_shape = self.prepare_image_initial_shape([1, 10, 20, 30], 1)
image = self.image_class(np.zeros(initial_shape, np.uint8), (1, 1, 1), "")
assert image.mask is None
assert not image.has_mask
image.set_mask(np.ones((10, 20, 30), np.uint8))
assert image.mask.shape == tuple(self.prepare_mask_shape((1, 10, 20, 30)))
assert image.has_mask
assert np.all(image.mask == 1)
image.set_mask(np.full((10, 20, 30), 5, np.uint8))
assert image.mask.shape == tuple(self.prepare_mask_shape((1, 10, 20, 30)))
assert np.all(image.mask == 1)
mask = np.full((10, 20, 30), 5, np.uint8)
mask[0, 0, 0] = 1
image.set_mask(mask)
assert image.mask.shape == tuple(self.prepare_mask_shape((1, 10, 20, 30)))
assert np.all(np.bincount(image.mask.flat) == (0, 1, 10 * 20 * 30 - 1))
image.set_mask(None)
assert image.mask is None
def test_set_mask_reorder(self):
image = self.image_class(np.zeros((1, 10, 20, 30, 1), np.uint8), (1, 1, 1), "", axes_order="TZYXC")
image.set_mask(np.ones((30, 20, 10), np.uint8), "XYZ")
assert image.mask.shape == self.mask_shape((1, 10, 20, 30), "TZYX")
def test_get_image_for_save(self):
image = self.image_class(np.zeros((1, 10, 3, 20, 30), np.uint8), (1, 1, 1), "", axes_order="TZCYX")
assert image.get_image_for_save().shape == (1, 10, 3, 20, 30)
image = self.image_class(np.zeros((1, 10, 20, 30, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC")
assert image.get_image_for_save().shape == (1, 10, 3, 20, 30)
def test_get_mask_for_save(self):
image = self.image_class(np.zeros((1, 10, 3, 20, 30), np.uint8), (1, 1, 1), "", axes_order="TZCYX")
assert image.get_mask_for_save() is None
image.set_mask(np.zeros((1, 10, 20, 30), np.uint8), axes="TZYX")
assert image.get_mask_for_save().shape == (1, 10, 1, 20, 30)
def test_image_properties(self):
image = self.image_class(np.zeros((1, 10, 20, 30, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC")
assert not image.has_mask
assert not image.is_time
assert image.is_stack
assert not image.is_2d
assert image.channels == 3
assert image.layers == 10
assert image.times == 1
assert image.plane_shape == (20, 30)
def test_swap_time_and_stack(self):
image = self.image_class(np.zeros((1, 10, 20, 30, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC")
image2 = image.swap_time_and_stack()
assert image.times == 1
assert image.layers == 10
assert image2.times == 10
assert image2.layers == 1
def test_get_channel(self):
image = self.image_class(
np.zeros((1, 10, 20, 30, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC", channel_names=["a", "b", "c"]
)
channel = image.get_channel(1)
assert channel.shape == self.mask_shape((1, 10, 20, 30), "TZYX")
channel = image.get_channel("b")
assert channel.shape == self.mask_shape((1, 10, 20, 30), "TZYX")
with pytest.raises(IndexError):
image.get_channel(4)
def test_get_layer(self):
image = self.image_class(np.zeros((1, 10, 20, 30, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC")
layer = image.get_layer(0, 5)
assert layer.shape == self.needed_shape((20, 30, 3), "YXC", "TZ")
def test_spacing(self):
image = self.image_class(np.zeros((1, 10, 20, 30, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC")
assert image.spacing == (1, 1, 1)
assert image.voxel_size == (1, 1, 1)
image.set_spacing((1, 2, 3))
assert image.spacing == (1, 2, 3)
assert image.voxel_size == (1, 2, 3)
with pytest.raises(ValueError):
image.set_spacing((1, 2, 3, 4))
with pytest.raises(TypeError):
# noinspection PyTypeChecker
image.set_spacing(1)
image.set_spacing((1, 0, 4))
assert image.spacing == (1, 2, 3)
assert image.voxel_size == (1, 2, 3)
def test_spacing_2d(self):
image = self.image_class(np.zeros((1, 1, 20, 30, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC")
assert image.spacing == (1, 1)
assert image.voxel_size == (1, 1)
image.set_spacing((1, 2))
assert image.spacing == (1, 2)
assert image.voxel_size == (1, 2)
def test_cut_image(self):
# TODO add tests for more irregular shape
image = self.image_class(np.zeros((1, 10, 20, 30, 3), np.uint8), (1, 1, 1), "", axes_order="TZYXC")
mask1 = np.zeros((1, 10, 20, 30), np.uint8)
mask1[0, 2:-2, 2:9, 2:-2] = 1
mask1[0, 2:-2, 11:-2, 2:-2] = 2
image.set_mask(mask1, "TZYX")
mask = image.mask
image.set_mask(np.zeros((1, 10, 20, 30), np.uint8), "TZYX")
im = image.cut_image(mask == 1, replace_mask=False)
assert np.all(im.mask == 0)
assert im.shape == self.image_shape((1, 10, 11, 30, 3), axes="TZYXC")
im = image.cut_image(mask == 2, replace_mask=True)
assert np.all(
im.mask[
:, FRAME_THICKNESS:-FRAME_THICKNESS, FRAME_THICKNESS:-FRAME_THICKNESS, FRAME_THICKNESS:-FRAME_THICKNESS
]
== 1
)
assert im.shape == self.image_shape((1, 10, 11, 30, 3), axes="TZYXC")
# Test cutting with list of slices
points = np.nonzero(mask == 2)
lower_bound = np.min(points, axis=1)
upper_bound = | np.max(points, axis=1) | numpy.max |
import math
import os
import numpy as np
import pygame
from gym import spaces
from gym.utils import seeding
from scipy.spatial import distance as ssd
from .._utils import Agent
os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = 'hide'
class Archea(Agent):
def __init__(self, idx, radius, n_sensors, sensor_range, max_accel, speed_features=True):
self._idx = idx
self._radius = radius
self._n_sensors = n_sensors
self._sensor_range = sensor_range
self._max_accel = max_accel
# Number of observation coordinates from each sensor
self._sensor_obscoord = 5
if speed_features:
self._sensor_obscoord += 3
self._sensor_obs_coord = self._n_sensors * self._sensor_obscoord
self._obs_dim = self._sensor_obs_coord + 2 # +1 for is_colliding_evader, +1 for is_colliding_poison
self._position = None
self._velocity = None
# Generate self._n_sensors angles, evenly spaced from 0 to 2pi
# We generate 1 extra angle and remove it because linspace[0] = 0 = 2pi = linspace[-1]
angles = np.linspace(0., 2. * np.pi, self._n_sensors + 1)[:-1]
# Convert angles to x-y coordinates
sensor_vectors = np.c_[np.cos(angles), np.sin(angles)]
self._sensors = sensor_vectors
@property
def observation_space(self):
return spaces.Box(low=np.float32(-np.sqrt(2)), high=np.float32(2 * np.sqrt(2)), shape=(self._obs_dim,), dtype=np.float32)
@property
def action_space(self):
return spaces.Box(low=np.float32(-self._max_accel), high=np.float32(self._max_accel), shape=(2,), dtype=np.float32)
@property
def position(self):
assert self._position is not None
return self._position
@property
def velocity(self):
assert self._velocity is not None
return self._velocity
def set_position(self, pos):
assert pos.shape == (2,)
self._position = pos
def set_velocity(self, velocity):
assert velocity.shape == (2,)
self._velocity = velocity
@property
def sensors(self):
assert self._sensors is not None
return self._sensors
def sensed(self, object_coord, object_radius, same=False):
"""Whether object would be sensed by the pursuers"""
relative_coord = object_coord - np.expand_dims(self.position, 0)
# Projection of object coordinate in direction of sensor
sensorvals = self.sensors.dot(relative_coord.T)
# Set sensorvals to np.inf when object should not be seen by sensor
distance_squared = (relative_coord**2).sum(axis=1)[None, :]
sensorvals[
(sensorvals < 0) # Wrong direction (by more than 90 degrees in both directions)
| (sensorvals - object_radius > self._sensor_range) # Outside sensor range
| (distance_squared - sensorvals**2 > object_radius**2) # Sensor does not intersect object
] = np.inf
if same:
# Set sensors values for sensing the current object to np.inf
sensorvals[:, self._idx - 1] = np.inf
return sensorvals
def sense_barriers(self, min_pos=0, max_pos=1):
sensor_vectors = self.sensors * self._sensor_range
sensor_endpoints = sensor_vectors + self.position
# Clip sensor lines on the environment's barriers.
# Note that any clipped vectors may not be at the same angle as the original sensors
clipped_endpoints = np.clip(sensor_endpoints, min_pos, max_pos)
# Extract just the sensor vectors after clipping
clipped_vectors = clipped_endpoints - self.position
# Find the ratio of the clipped sensor vector to the original sensor vector
# Scaling the vector by this ratio will limit the end of the vector to the barriers
ratios = np.divide(clipped_vectors, sensor_vectors, out=np.ones_like(clipped_vectors),
where=np.abs(sensor_vectors) > 0.00000001)
# Find the minimum ratio (x or y) of clipped endpoints to original endpoints
minimum_ratios = np.amin(ratios, axis=1)
# Convert to 2d array of size (n_sensors, 1)
sensor_values = | np.expand_dims(minimum_ratios, 0) | numpy.expand_dims |
import unittest
import os
from datetime import datetime
from datetime import timedelta
import numpy as np
from cassandra.cqlengine import connection
from cassandra.cqlengine.query import BatchQuery
from cassandra.cqlengine.management import sync_table
from solar_data_pipeline.database.cassandra import CassandraDataAccess
from solar_data_pipeline.database.models.measurements import MeasurementRaw
from solar_data_pipeline.database.models.measurements import Geopoint
@unittest.skip("This test accesses Cassandra database." +
"Thus, this test will not be a part of continuous integration.")
class TestCassandraDataAccess(unittest.TestCase):
"""
This test depends on Cassandra database thus cannot be run in Continuous
Integration Server, since Cassandra database doesn't have in-memory
database as sqlite in-memory database that can be used for testing in place
of other relational database such as PostgreSQL or MySQL.
"""
@classmethod
def setUpClass(self):
input_power_signals_file_path = os.path.abspath(
os.path.join(os.path.dirname(__file__),
"../../fixtures/one_year_power_signals_1.csv"))
with open(input_power_signals_file_path) as file:
one_year_power_signals = np.loadtxt(file, delimiter=',')
# Use only 6 days in order to reduce execution time:
TestCassandraDataAccess._power_signals_site_1 = one_year_power_signals[
:, :6]
TestCassandraDataAccess._power_signals_site_2 = one_year_power_signals[
:, 6:12]
# Temp:
# import matplotlib.pyplot as plt
# plt.imshow(TestCassandraDataAccess._power_signals_site_1)
# plt.show()
TestCassandraDataAccess._cassandra_ip_address = '127.0.0.1'
connection.setup([TestCassandraDataAccess._cassandra_ip_address],
"measurements")
# Note: For now, populate database and keep the data.
# When commit, make sure to put back the code to clean database.
# start_time = datetime(2019, 1, 1, 0, 0, 0)
#
# TestCassandraDataAccess._raw_measurements = []
# TestCassandraDataAccess._populate_database(
# TestCassandraDataAccess._power_signals_site_1, "SLACA0000001",
# start_time)
# TestCassandraDataAccess._populate_database(
# TestCassandraDataAccess._power_signals_site_2, "SLACA0000002",
# start_time)
@classmethod
def tearDownClass(self):
# Note: For now, populate database and keep the data.
# When commit, make sure to put back the code to clean database.
# for raw_measurement in TestCassandraDataAccess._raw_measurements:
# raw_measurement.delete()
pass
@classmethod
def _populate_database(self, power_signals, site_name, start_time):
timedelta_value = 0
for i, daily_signal in enumerate(power_signals.T):
for j, value in enumerate(daily_signal):
TestCassandraDataAccess._raw_measurements.append(
MeasurementRaw.create(
site = site_name,
meas_name = "ac_power",
ts = start_time + timedelta(minutes=timedelta_value),
sensor = "000001-0A00-0001_ABC-1000p-AA-1",
station = "001_inverter",
company = "SLAC",
lat_lon = Geopoint(latitude = 35.00000,
longitude = -120.00000),
meas_description = None,
meas_status = True,
meas_unit = "kW",
meas_val_b = None,
meas_val_f = value,
meas_val_s = None)
)
timedelta_value += 5
def _assert_number_of_matching_daily_signals(self, actual, original_data,
expected_number_of_data_match):
# data_match = (actual == original_data)
data_match = np.array([np.allclose(actual[i],
original_data[i], rtol=1e-04, atol=1e-06)
for i in range(len(original_data))])
actual_number_of_data_match = np.sum(data_match)
self.assertEqual(actual_number_of_data_match,
expected_number_of_data_match)
@unittest.skip("This test accesses Cassandra database." +
"Thus, this test will not be a part of continuous integration.")
def test_find_sites(self):
data_access = CassandraDataAccess(
TestCassandraDataAccess._cassandra_ip_address)
actual_sites = data_access.find_sites("SLACA0000001")
expected_sites = np.array(["SLACA0000001"])
np.testing.assert_array_equal(actual_sites, expected_sites)
actual_nonexisting_sites = data_access.find_sites("SLACA9999999")
expected_nonexisting_sites = | np.array([]) | numpy.array |
import re
import math
from collections import Counter
import os
import string
from read import *
import pandas as pd
from pandas import ExcelWriter, ExcelFile
import numpy as np
import matplotlib.pyplot as plt
import spacy
from nltk.corpus import stopwords
import nltk
from sklearn.linear_model import LinearRegression
from sklearn.cross_validation import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.externals import joblib
import sendgrid
from sendgrid.helpers.mail import *
pd.options.mode.chained_assignment = None
'''
CODES AND THEIR MEANINGS:
ml -> Machine Learning
bc -> Blockchain
ai -> Artificial Intelligence
su -> StartUp
prod -> Product
dev -> Development
'''
######################################### CUSTOM FUNCTIONS TO PERFORM TASKS #############################################
email_list = ["<EMAIL>","<EMAIL>", "<EMAIL>"]
sg = sendgrid.SendGridAPIClient(apikey="<KEY>")
WORD = re.compile(r'\w+')
def custom_sum(df_list): #Custom sum function to calculate likes as some fields have video views as well in dataset
summ = 0 #Initialising value to zero
for val in df_list: #Running through the entire column
if(type(val)!=int): #Checking if the value is a pure integer or not
continue #If not, then continue to next value
summ += val #Else add the val to summ
return summ
def custom_time_sum(df_list): #Custom time sum function to calculate the sum of times in the dataset by removing " hours"
summ = 0
for val in df_list: #Checking for every value in the column
val = val.replace(u' hours',u'') #Replacing " hours" with a null string
summ += int(val) #Adding the integral value of hours to summ
return summ
def custom_time_list(df_list): #Custom time sum function to calculate the sum of times in the dataset by removing " hours"
#print(df_list)
for i in range(0,len(df_list)): #Checking for every value in the column
df_list[i] = df_list[i].replace(u' hours',u'') #Replacing " hours" with a null string
df_list[i] = int(df_list[i]) #Adding the integral value of hours to summ
return df_list
def get_cosine(vec1, vec2):
intersection = set(vec1.keys()) & set(vec2.keys())
numerator = sum([vec1[x] * vec2[x] for x in intersection])
sum1 = sum([vec1[x]**2 for x in vec1.keys()])
sum2 = sum([vec2[x]**2 for x in vec2.keys()])
denominator = math.sqrt(sum1) * math.sqrt(sum2)
return float(numerator) / denominator
def text_to_vector(text):
words = WORD.findall(text)
return Counter(words)
def dataset_hashtag_generator(df_list):
try:
nlp = spacy.load("en_core_web_sm")
except:
os.system("python3 -m spacy download en")
nlp = spacy.load("en_core_web_sm")
try:
stopw = stopwords.words("english")
except:
os.system("python3 -m nltk.downloader stopwords")
stopw = stopwords.words("english")
noun_list = []
for i in range(0, len(df_list)-1):
print(df_list[i])
try:
if(np.isnan(df_list[i])):
continue
except:
df_list[i] = re.sub(r'https?:\/\/.*\/\w*','',df_list[i]) # Remove hyperlinks
df_list[i] = re.sub(r'['+string.punctuation+']+', ' ',df_list[i]) # Remove puncutations like 's
df_list[i] = df_list[i].replace("#","")
emoji_pattern = re.compile("["u"\U0001F600-\U0001F64F" u"\U0001F300-\U0001F5FF" u"\U0001F680-\U0001F6FF" u"\U0001F1E0-\U0001F1FF""]+", flags=re.UNICODE) #Removes emoji
df_list[i] = emoji_pattern.sub(r'', df_list[i]) # no emoji
doc = nlp(df_list[i])
temp_list = []
for sent in doc.sents:
for token in sent:
token_temp = str(token)
if(token.pos_=="NOUN" and token.text not in stopw):
#print(sent)
#print(i, token.text)
temp_list.append(token.text)
noun_list.append(temp_list)
temp_list = []
print(noun_list)
return noun_list
def caption_hashtag_generator(sentence):
nlp = spacy.load("en_core_web_sm")
stopw = stopwords.words("english")
noun_list = []
sentence = re.sub(r'https?:\/\/.*\/\w*','',sentence) # Remove hyperlinks
sentence = re.sub(r'['+string.punctuation+']+', ' ',sentence) # Remove puncutations like 's
sentence = sentence.replace("#","")
emoji_pattern = re.compile("["u"\U0001F600-\U0001F64F" u"\U0001F300-\U0001F5FF" u"\U0001F680-\U0001F6FF" u"\U0001F1E0-\U0001F1FF""]+", flags=re.UNICODE) #Removes emoji
sentence = emoji_pattern.sub(r'', sentence) # no emoji
doc = nlp(sentence)
temp_list = []
for sent in doc.sents:
for token in sent:
token_temp = str(token)
#print(sent)
print(token.text, token.pos_)
if(token.pos_=="NOUN" and token.text not in stopw):
#print(sent)
#print(i, token.text)
temp_list.append(token.text)
noun_list.append(temp_list)
temp_list = []
#print(noun_list)
return noun_list
def data_science(df, df_list):
hashtags = [] #Initialising hashtags list
for hs in df["Hashtags"]: #Reading every hashtag that was used in posts
hashtags += hs.split("#") #Every field in Hashtags column contains more than one hashtag so need to identify all. That's why using the split at # thing
#print(hashtags)
for elem in range(0,len(hashtags)): #If we print hashtags list before, it gives a non breaking space(\xa0) so need to replace it with null character or empty string
hashtags[elem] = hashtags[elem].replace(u'\xa0',u'') #Replacement happens here
#print(hashtags)
fdist = nltk.FreqDist(hashtags) #freqdist function present in nltk
fdist.plot(20) #Finding top 20 hashtags
frame_ml.plot(x="Followers", y="Likes", figsize=(50,100), style="o")
frame_ai.plot(x="Followers", y="Likes", figsize=(50,100), style="o")
frame_bc.plot(x="Followers", y="Likes", figsize=(50,100), style="o")
frame_su.plot(x="Followers", y="Likes", figsize=(50,100), style="o")
frame_prod.plot(x="Followers", y="Likes", figsize=(50,100), style="o")
frame_dev.plot(x="Followers", y="Likes", figsize=(50,100), style="o")
plt.show()
mean_likes_ml = round(custom_sum(frame_ml['Likes'].tolist())/len(frame_ml))
mean_likes_bc = round(custom_sum(frame_bc['Likes'].tolist())/len(frame_bc))
mean_likes_ai = round(custom_sum(frame_ai['Likes'].tolist())/len(frame_ai))
mean_likes_su = round(custom_sum(frame_su['Likes'].tolist())/len(frame_su))
mean_likes_prod = round(custom_sum(frame_prod['Likes'].tolist())/len(frame_prod))
mean_likes_dev = round(custom_sum(frame_dev['Likes'].tolist())/len(frame_dev))
mean_time_ml = round(custom_time_sum(frame_ml['Time since posted'].tolist())/len(frame_ml))
mean_time_bc = round(custom_time_sum(frame_bc['Time since posted'].tolist())/len(frame_bc))
mean_time_ai = round(custom_time_sum(frame_ai['Time since posted'].tolist())/len(frame_ai))
mean_time_su = round(custom_time_sum(frame_su['Time since posted'].tolist())/len(frame_su))
mean_time_prod = round(custom_time_sum(frame_prod['Time since posted'].tolist())/len(frame_prod))
mean_time_dev = round(custom_time_sum(frame_dev['Time since posted'].tolist())/len(frame_dev))
mean_follow_ml = round(np.sum(frame_ml['Followers'])/len(frame_ml))
mean_follow_bc = round(np.sum(frame_bc['Followers'])/len(frame_bc))
mean_follow_ai = round(np.sum(frame_ai['Followers'])/len(frame_ai))
mean_follow_su = round(np.sum(frame_su['Followers'])/len(frame_su))
mean_follow_prod = round(np.sum(frame_prod['Followers'])/len(frame_prod))
mean_follow_dev = round( | np.sum(frame_dev['Followers']) | numpy.sum |
import numpy as np
from powerbox.tools import angular_average_nd, angular_average, get_power
from powerbox.powerbox import PowerBox
import pytest
def test_angular_avg_nd_3():
x = np.linspace(-3,3,400)
X,Y = np.meshgrid(x,x)
r2 = X**2 + Y**2
P = r2**-1.
P = np.repeat(P,100).reshape(400,400,100)
freq = [x,x,np.linspace(-2,2,100)]
p_k, k_av_bins = angular_average_nd(P,freq,bins=50,n=2)
print(p_k[6:,0], k_av_bins[6:]**-2.)
assert np.max(np.abs((p_k[6:,0] - k_av_bins[6:]**-2.)/k_av_bins[6:]**-2.)) < 0.05
def test_angular_avg_nd_4_2():
x = np.linspace(-3,3,200)
X,Y = np.meshgrid(x,x)
r2 = X**2 + Y**2
P = r2**-1.
P = np.repeat(P, 10).reshape(200,200,10)
P = np.repeat(P, 10).reshape(200, 200, 10, 10)
freq = [x,x,np.linspace(-2,2,10), np.linspace(-2,2,10)]
p_k, k_av_bins = angular_average_nd(P,freq,bins=50,n=2)
print(np.abs((p_k[7:,0,0] - k_av_bins[7:]**-2.)/k_av_bins[7:]**-2.))
assert np.max(np.abs((p_k[6:,0,0] - k_av_bins[6:]**-2.)/k_av_bins[6:]**-2.)) < 0.06
def test_angular_avg_nd_2_1_varnull():
x = np.linspace(-3,3,200)
P = np.ones((200,10))
coords = [x, np.linspace(-2,2,10)]
p_k, k_av_bins, var = angular_average_nd(P,coords, bins=20, n=1, get_variance=True)
assert np.all(var==0)
def test_null_variance_2d():
x = np.linspace(-3, 3, 400)
X, Y = np.meshgrid(x, x)
r2 = X ** 2 + Y ** 2
P = np.ones_like(r2)
ave, coord, var = angular_average(P, np.sqrt(r2), bins=np.linspace(0,x.max(), 20), get_variance=True)
assert np.all(var==0)
def test_variance_2d():
x = np.linspace(-3, 3, 400)
X, Y = np.meshgrid(x, x)
r2 = X ** 2 + Y ** 2
P = np.ones_like(r2)
P += np.random.normal(scale=1, size=(len(x), len(x)))
ave, coord, var = angular_average(P, np.sqrt(r2), bins=np.linspace(0,x.max(), 20), get_variance=True)
print(np.diff(var))
assert np.all(np.diff(var)<=0)
def test_complex_variance():
x = np.linspace(-3, 3, 400)
X, Y = np.meshgrid(x, x)
r2 = X ** 2 + Y ** 2
P = np.ones_like(r2) + np.ones_like(r2)*1j
with pytest.raises(NotImplementedError):
ave, coord, var = angular_average(P, np.sqrt(r2), bins=np.linspace(0, x.max(), 20), get_variance=True)
def test_bin_edges():
x = np.linspace(-3,3,200)
X,Y = np.meshgrid(x,x)
r2 = X**2 + Y**2
P = r2**-1.
bins = np.linspace(0, x.max(), 20)
ave, coord = angular_average(P, np.sqrt(r2), bins=bins, bin_ave=False)
assert np.all(coord==bins)
def test_sum():
x = np.linspace(-3, 3, 200)
X, Y = | np.meshgrid(x, x) | numpy.meshgrid |
from scipy import sparse
#import matplotlib.pyplot as plt
import os
#import tensorflow as tf
import numpy as np
import scipy
from mpl_toolkits.mplot3d import Axes3D
from plyfile import PlyData, PlyElement
# from IPython.display import clear_output
import os
from shapely.geometry import Point
from shapely.geometry.polygon import Polygon
import vispy.geometry
from matplotlib import path
from scipy.spatial.distance import cdist
def totuple(a):
return [ tuple(i) for i in a]
def plotly_trisurf(V, TRIV):
p3.clear()
p3.plot_trisurf(V[:,0], V[:,1], V[:,2], triangles=TRIV)
p3.scatter(V[:,0], V[:,1], V[:,2], marker='sphere', color='blue', size=0.33)
p3.squarelim()
p3.show()
import time
def TicTocGenerator():
# Generator that returns time differences
ti = 0 # initial time
tf = time.time() # final time
while True:
ti = tf
tf = time.time()
yield tf-ti # returns the time difference
TicToc = TicTocGenerator() # create an instance of the TicTocGen generator
# This will be the main function through which we define both tic() and toc()
def toc(tempBool=True):
# Prints the time difference yielded by generator instance TicToc
tempTimeInterval = next(TicToc)
if tempBool:
print( "Elapsed time: %f seconds.\n" %tempTimeInterval )
def tic():
# Records a time in TicToc, marks the beginning of a time interval
toc(False)
#def pteval(X):
def tfeval(X):
gpu_options = tf.GPUOptions(allow_growth = True)
config = tf.ConfigProto(device_count={'CPU': 1, 'GPU': 0},
allow_soft_placement = False, gpu_options=gpu_options)
sess = tf.Session(config=config)
tf.global_variables_initializer().run(session=sess)
#[tfEvals, tfEvecs] = tf.self_adjoint_eig(X)
#[evals, evecs] = sess.run( [tfEvals, tfEvecs] );
x = sess.run(tf.identity(X) );
sess.close();
return x
def tfeig(X):
gpu_options = tf.GPUOptions(allow_growth = True)
config = tf.ConfigProto(device_count={'CPU': 1, 'GPU': 0},
allow_soft_placement = False, gpu_options=gpu_options)
sess = tf.Session(config=config)
tf.global_variables_initializer().run(session=sess)
#[tfEvals, tfEvecs] = tf.self_adjoint_eig(X)
#[evals, evecs] = sess.run( [tfEvals, tfEvecs] );
LAP = sess.run(tf.identity(X) );
sess.close();
[evals, evecs] = scipy.linalg.eigh(LAP);
evals = np.diag(evals)
return evals, evecs, LAP
def load_mesh(path):
VERT = np.loadtxt(path+'/mesh.vert')
TRIV = np.loadtxt(path+'/mesh.triv',dtype='int32')-1
return VERT, TRIV
def totuple(a):
return [ tuple(i) for i in a]
def save_ply(V,T,filename):
if(V.shape[1]==2):
Vt = np.zeros((V.shape[0],3))
Vt[:,0:2] = V
V = Vt
vertex = np.array(totuple(V),dtype=[('x', 'f4'), ('y', 'f4'),('z', 'f4')])
# print([ tuple([i]) for i in T])
face = np.array([ tuple([i]) for i in T],dtype=[('vertex_indices', 'i4', (3,))])
el1 = PlyElement.describe(vertex, 'vertex')
el2 = PlyElement.describe(face, 'face')
PlyData([el1,el2]).write(filename)
#PlyData([el2]).write('some_binary.ply')
def load_ply(fname):
plydata = PlyData.read(fname)
VERT = np.asarray([ (v[0],v[1],v[2]) for v in plydata.elements[0].data])
TRIV = np.asarray([ t[0] for t in plydata.elements[1].data])
return VERT,TRIV
def ismember(T, pts):
out = np.zeros(np.shape(T)[0])
for r in range(np.shape(T)[0]):
s=0
for c in range(np.shape(T)[1]):
if np.sum(T[r,c]==pts)>0: s=s+1;
out[r] = s>0;
return out
def prepare_mesh(VERT,TRIV,dtype='float32'):
edges = np.ones(shape=(np.shape(VERT)[0],np.shape(VERT)[0],2),dtype='int32')*-1
edges_count = np.zeros(shape=(np.shape(VERT)[0],np.shape(VERT)[0]),dtype='int32')
def setedg(i,j,k):
_setedg(i,j,k)
_setedg(j,i,k)
def _setedg(i,j,k):
edges_count[i,j] +=1
if edges[i,j,0]==k:
return
if edges[i,j,1]==k:
return
if edges[i,j,0]==-1:
# print(edges[i,j,0])
edges[i,j,0]=k
else:
edges[i,j,1]=k
for ti in range(np.shape(TRIV)[0]):
setedg(TRIV[ti,0],TRIV[ti,1],TRIV[ti,2])
setedg(TRIV[ti,2],TRIV[ti,0],TRIV[ti,1])
setedg(TRIV[ti,1],TRIV[ti,2],TRIV[ti,0])
n = np.shape(VERT)[0]
m = int(np.sum( ((edges[:,:,0]>=0) + (edges[:,:,1]>=0)) >0)/2);
map_ = np.ones(shape=(n,n),dtype='int32')*-1;
invmap = np.ones(shape=(m,2),dtype='int32')*-1;
iM = np.zeros(shape=(m,n),dtype=dtype);
bound_edges = np.zeros(shape=(m,1),dtype='bool');
idx=0
for i in range(n):
for j in range(i+1,n):
if(edges[i,j,0]==-1 and edges[i,j,1]==-1): continue;
map_[i,j] = idx;
map_[j,i] = idx;
invmap[idx,:] = [i,j]
iM[idx,i] = 1;
iM[idx,j] = -1;
bound_edges[idx,0] = edges_count[i,j]<2
idx=idx+1;
# print(idx)
# Set Ael for existing edgeIdx with vertex i to 1
Ael = np.zeros(shape=(n,m),dtype=dtype);
for i in range(n):
Ael[i,map_[i,np.nonzero(map_[i,:]+1)]]=1
Ik = np.zeros(shape=(m,m),dtype=dtype);
Ih = np.zeros(shape=(m,m),dtype=dtype);
Ik_k = np.zeros(shape=(m,m,3),dtype=dtype);
Ih_k = | np.zeros(shape=(m,m,3),dtype=dtype) | numpy.zeros |
import pytest
import numpy as np
def test_randlanet_torch():
import torch
import open3d.ml.torch as ml3d
net = ml3d.models.RandLANet(num_points=5000, num_classes=10, dim_input=6)
net.device = 'cpu'
data = {
'point':
np.array(np.random.random((1000, 3)), dtype=np.float32),
'feat':
np.array(np.random.random((1000, 3)), dtype=np.float32),
'label':
np.array([np.random.randint(10) for i in range(1000)],
dtype=np.int32)
}
attr = {'split': 'train'}
data = net.preprocess(data, attr)
inputs = net.transform(data, attr)
inputs = {
'xyz': [torch.from_numpy(np.array([item])) for item in inputs['xyz']],
'neigh_idx': [
torch.from_numpy(np.array([item])) for item in inputs['neigh_idx']
],
'sub_idx': [
torch.from_numpy(np.array([item])) for item in inputs['sub_idx']
],
'interp_idx': [
torch.from_numpy( | np.array([item]) | numpy.array |
import itertools as it
import numpy as np
import torch as tr
import matplotlib.pyplot as pt
from ghu import *
from codec import Codec
from controller import Controller
from lvd import lvd
from reinforce import *
import json
def trials(i, avgrew, avggen, gradnorm):
print("***************************** Trial ",str(i+1)," *******************************")
# Configuration
num_symbols = 10
layer_sizes = {"rinp": 32, "rout":32, "rtemp":32}
hidden_size = 32
rho = .99
plastic = []
num_episodes = 500
# Setup GHU
symbols = [str(a) for a in range(num_symbols)]
pathways, associations = default_initializer( # all to all
layer_sizes.keys(), symbols)
codec = Codec(layer_sizes, symbols, rho=rho, ortho=True)
controller = Controller(layer_sizes, pathways, hidden_size, plastic)
ghu = GatedHebbianUnit(
layer_sizes, pathways, controller, codec, plastic=plastic, batch_size = num_episodes)
ghu.associate(associations)
# Initialize layers
separator = symbols[0]
ghu.fill_layers(separator)
# Generate dataset
input_length = 5
all_inputs = [ | np.array(inputs) | numpy.array |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@ package pi_FPE
@ file marginsofstability.py
@ author <NAME>
@ brief calculates the margins of stability in ap and ml direction.
Spits out the relavant PIs in yaml format.
@usage:
events = calcMOS(joint,com,events,trlinfo)
Copyright (C) 2020 Vrije Universiteit Amsterdam (FGB-Human Movement Sciences)
Distributed under the pache 2.0 license.
"""
import numpy as np
def calcMOS(joint,com,events,trlinfo):
print("Calculating Margins of Stability...")
# get time vector
t = joint.time
# get sampling frequency
fs = 1/np.nanmean(np.diff(t))
# set the gravitational acceleration
g = 9.81 #m/s
# event timing to index number
lhs = np.array(events.l_heel_strike)*fs
rhs = np.array(events.r_heel_strike)*fs
lto = np.array(events.l_toe_off)*fs
rto = np.array(events.r_toe_off)*fs
# get toe markers
ltoe = np.transpose(np.vstack((joint.l_TTII_x,joint.l_TTII_y,joint.l_TTII_z)))
rtoe = np.transpose(np.vstack((joint.r_TTII_x,joint.r_TTII_y,joint.r_TTII_z)))
# get heel markers
lheel = np.transpose(np.vstack((joint.l_heel_x,joint.l_heel_y,joint.l_heel_z)))
rheel = np.transpose(np.vstack((joint.r_heel_x,joint.r_heel_y,joint.r_heel_z)))
# get hips
rhip = np.transpose(np.vstack((joint.l_hip_x,joint.l_hip_y,joint.l_hip_z)))
lhip = np.transpose(np.vstack((joint.r_hip_x,joint.r_hip_y,joint.r_hip_z)))
# determine walking directions
walkdir = np.argmax(np.ptp( | np.array(lheel) | numpy.array |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from scipy.signal import *
def srange(x):
x -= x.min()
x /= x.max()
return x
def signal(i,x,sigma,n1,n2,n3,n4):
n_ftrs = x.shape[0]
n = np.random.normal(0,sigma,n_ftrs)
n1 = | np.random.uniform(1-n1,1+n1) | numpy.random.uniform |
## interaction / scripts / create_translation_repository.py
'''
This script will pre-calculate the translation operators for a given bounding
box, max level, and frequency steps for a multi-level fast multipole algorithm.
This can take hours to days depending on the number of threads available, size
of bounding box, number of levels etc. The output is stored in a single H5 file.
To use, run with a corresponding yaml config file for setting the input
parameters.
python create_translation_repository.py <path to config file>
Author: <NAME> (<EMAIL>)
'''
import numpy as np
import pandas as pd
import sqlite3 as sql
import multiprocessing
from itertools import repeat
from contextlib import closing
import os
from tqdm import tqdm
from interaction3.bem.core import fma_functions as fma
from interaction3.bem.core.db_functions import get_order
# register adapters for sqlite to convert numpy types
sql.register_adapter(np.float64, float)
sql.register_adapter(np.float32, float)
sql.register_adapter(np.int64, int)
sql.register_adapter(np.int32, int)
## PROCESS FUNCTIONS ##
def generate_translations(file, f, k, dims, levels, orders_db):
xdim, ydim = dims
minlevel, maxlevel = levels
for l in range(minlevel, maxlevel + 1):
order = get_order(orders_db, f, l)
qrule = fma.fft_quadrule(order, order)
group_xdim, group_ydim = xdim / (2 ** l), ydim / (2 ** l)
kcoordT = qrule['kcoordT']
theta = qrule['theta']
phi = qrule['phi']
unique_coords = fma.get_unique_coords()
for coords in unique_coords:
r = coords * np.array([group_xdim, group_ydim, 1])
rhat = r / fma.mag(r)
cos_angle = rhat.dot(kcoordT)
translation = np.ascontiguousarray(fma.mod_ff2nf_op(fma.mag(r), cos_angle, k, order))
with write_lock:
with closing(sql.connect(file)) as conn:
update_translations_table(conn, f, k, l, order, tuple(coords), theta, phi, translation)
def init_process(_write_lock):
global write_lock
write_lock = _write_lock
def process(proc_args):
file, f, k, dims, levels, orders_db = proc_args
generate_translations(file, f, k, dims, levels, orders_db)
with write_lock:
with closing(sql.connect(file)) as conn:
update_progress(conn, f)
## ENTRY POINT ##
def main(**kwargs):
threads = kwargs['threads']
freqs = kwargs['freqs']
levels = kwargs['levels']
dims = kwargs['dims']
c = kwargs['sound_speed']
file = kwargs['file']
orders_db = kwargs['orders_db']
# set default threads to logical core count
if threads is None:
threads = multiprocessing.cpu_count()
kwargs['threads'] = threads
# path to this module's directory
module_dir = os.path.dirname(os.path.realpath(__file__))
# set default file name for database
if file is None:
file = os.path.join(module_dir, 'translations_dims_{:0.4f}_{:0.4f}.db'.format(*dims))
kwargs['file'] = file
# set default file nam of orders database to use
if orders_db is None:
orders_db = os.path.join(module_dir, 'orders_dims_{:0.4f}_{:0.4f}.db'.format(*dims))
kwargs['orders_db'] = orders_db
# read orders database and form interpolating functions
# orders_interp_funcs = get_orders_interp_funcs(orders_db, levels)
# check for existing file
if os.path.isfile(file):
# conn = sql.connect(file)
response = input('Database ' + str(file) + ' already exists. \nContinue (c), Overwrite (o), or Do nothing ('
'any other key)?')
if response.lower() in ['o', 'overwrite']:
os.remove(file)
# determine frequencies and wavenumbers
f_start, f_stop, f_step = freqs
fs = np.arange(f_start, f_stop + f_step, f_step)
ks = 2 * np.pi * fs / c
# create database
with closing(sql.connect(file)) as conn:
# create database tables
create_metadata_table(conn, **kwargs)
create_frequencies_table(conn, fs, ks)
create_levels_table(conn, levels)
create_coordinates_table(conn)
create_translations_table(conn)
elif response.lower() in ['c', 'continue']:
with closing(sql.connect(file)) as conn:
query = '''
SELECT frequency, wavenumber FROM frequencies
WHERE is_complete=0
'''
table = pd.read_sql(query, conn)
fs = np.array(table['frequency'])
ks = np.array(table['wavenumber'])
else:
raise Exception('Database already exists')
else:
# Make directories if they do not exist
file_dir = os.path.dirname(file)
if not os.path.exists(file_dir):
os.makedirs(file_dir)
# determine frequencies and wavenumbers
f_start, f_stop, f_step = freqs
fs = | np.arange(f_start, f_stop + f_step, f_step) | numpy.arange |
#Tools to study and correct for trends in spectroscopic succes rate (ssr)
#Initial LRG model fitting taken from <NAME> notebook
import sys, os, glob, time, warnings, gc
import numpy as np
import matplotlib.pyplot as plt
from astropy.table import Table, vstack, hstack, join
import fitsio
from scipy.optimize import curve_fit, minimize
import LSS.common_tools as common
elgcol = ['SUBSET','EBV','PRIORITY','TARGETID','OII_FLUX','OII_FLUX_IVAR','ELG_LOP','ELG_VLO','TSNR2_ELG','TSNR2_LRG','PHOTSYS','MASKBITS','FIBERFLUX_G','FIBERFLUX_R','FIBERFLUX_Z','COADD_FIBERSTATUS','Z','ZWARN','DELTACHI2']
def ELG_goodobs(data,fbs_col='COADD_FIBERSTATUS'):#,dt_col='DESI_TARGET'):
mask = data[fbs_col]==0
print(fbs_col,np.sum(mask), np.sum(~mask), np.sum(~mask)/len(mask))
# Remove "no data" fibers
mask &= data['ZWARN'] & 2**9==0
print('& No data', np.sum(mask), np.sum(~mask), np.sum(~mask)/len(mask))
# Apply imaging mask
#mask &= data['lrg_mask']==0
#print('& LRG imaging mask', np.sum(mask), np.sum(~mask), np.sum(~mask)/len(mask))
data['q'] = ELG_goodz(data)#data['ZWARN']==0
print('failure rate is '+str(np.sum(~data['q'])/len(data)))
return data
def ELG_goodz(data,zcol='Z'):
o2c = np.log10(data['OII_FLUX'] * np.sqrt(data['OII_FLUX_IVAR']))+0.2*np.log10(data['DELTACHI2'])
sel = o2c > 0.9
return sel
def LRG_goodobs(data,fbs_col='COADD_FIBERSTATUS',dt_col='DESI_TARGET'):
mask = data[fbs_col]==0
print(fbs_col,np.sum(mask), np.sum(~mask), np.sum(~mask)/len(mask))
# Remove "no data" fibers
mask &= data['ZWARN'] & 2**9==0
print('& No data', np.sum(mask), np.sum(~mask), np.sum(~mask)/len(mask))
# Apply LRG mask
#mask &= data['lrg_mask']==0
#print('& LRG imaging mask', np.sum(mask), np.sum(~mask), np.sum(~mask)/len(mask))
# Remove QSO targets
mask &= data[dt_col] & 2**2 ==0
print('& Remove QSO targets', np.sum(mask), np.sum(~mask), np.sum(~mask)/len(mask))
data = data[mask]
data['q'] = LRG_goodz(data)#data['ZWARN']==0
#data['q'] &= data['Z']<1.5
#data['q'] &= data['DELTACHI2']>15
print('failure rate is '+str(np.sum(~data['q'])/len(data)))
return data
def LRG_goodz(data,zcol='Z'):
sel = data['ZWARN']==0
sel &= data[zcol]<1.5
sel &= data['DELTACHI2']>15
return sel
def get_ELG_data_full(tracer,surveys=['DA02'],versions=['test'],specrels=['guadalupe']):
cats = []
for sur,ver,sr in zip(surveys,versions,specrels):
dir = '/global/cfs/cdirs/desi/survey/catalogs/'+sur+'/LSS/'+sr+'/LSScats/'+ver+'/'
tfn = tracer
if sur == 'DA02':
tfn+='zdone'
fn = dir+tfn+'_full.dat.fits'
data = Table(fitsio.read(fn))
print(len(data))
sel = data['ZWARN'] != 999999
data = data[sel]
print(len(data))
data['q'] = data['o2c'] > 0.9
cats.append(data)
if len(cats) == 1:
cat = cats[0]
cat['EFFTIME_ELG'] = 8.60 * cat['TSNR2_ELG']
cat['EFFTIME_LRG'] = 12.15 * cat['TSNR2_LRG']
cat['zfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_Z']) - 1.211 * cat['EBV']
cat['FIBERFLUX_Z_EC'] = cat['FIBERFLUX_Z']*10**(0.4*1.211*cat['EBV'])
gextc = 3.214
cat['gfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_G']) - gextc * cat['EBV']
cat['FIBERFLUX_G_EC'] = cat['FIBERFLUX_G']*10**(0.4*gextc*cat['EBV'])
rextc = 2.165
cat['rfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_R']) - rextc * cat['EBV']
cat['FIBERFLUX_R_EC'] = cat['FIBERFLUX_R']*10**(0.4*rextc*cat['EBV'])
cat['qf'] = np.array(cat['q'], dtype=float)
return cat
def get_BGS_data_full(tracer,surveys=['DA02'],versions=['test'],specrels=['guadalupe']):
cats = []
for sur,ver,sr in zip(surveys,versions,specrels):
dir = '/global/cfs/cdirs/desi/survey/catalogs/'+sur+'/LSS/'+sr+'/LSScats/'+ver+'/'
tfn = tracer
if sur == 'DA02':
tfn+='zdone'
fn = dir+tfn+'_full.dat.fits'
data = Table(fitsio.read(fn))
print(len(data))
sel = data['ZWARN'] != 999999
data = data[sel]
print(len(data))
gz = data['ZWARN'] == 0
gz &= data['DELTACHI2'] > 40
data['q'] = gz
cats.append(data)
if len(cats) == 1:
cat = cats[0]
cat['EFFTIME_ELG'] = 8.60 * cat['TSNR2_ELG']
cat['EFFTIME_LRG'] = 12.15 * cat['TSNR2_LRG']
cat['EFFTIME_BGS'] = 12.15/89.8 * cat['TSNR2_BGS']
cat['zfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_Z']) - 1.211 * cat['EBV']
cat['FIBERFLUX_Z_EC'] = cat['FIBERFLUX_Z']*10**(0.4*1.211*cat['EBV'])
gextc = 3.214
cat['gfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_G']) - gextc * cat['EBV']
cat['FIBERFLUX_G_EC'] = cat['FIBERFLUX_G']*10**(0.4*gextc*cat['EBV'])
rextc = 2.165
cat['rfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_R']) - rextc * cat['EBV']
cat['FIBERFLUX_R_EC'] = cat['FIBERFLUX_R']*10**(0.4*rextc*cat['EBV'])
cat['qf'] = np.array(cat['q'], dtype=float)
return cat
def get_QSO_data_full(tracer,surveys=['DA02'],versions=['test'],specrels=['guadalupe']):
cats = []
for sur,ver,sr in zip(surveys,versions,specrels):
dir = '/global/cfs/cdirs/desi/survey/catalogs/'+sur+'/LSS/'+sr+'/LSScats/'+ver+'/'
tfn = tracer
if sur == 'DA02':
tfn+='zdone'
fn = dir+tfn+'_full.dat.fits'
data = Table(fitsio.read(fn))
print(len(data))
sel = data['ZWARN'] != 999999
sel &= data['SPECTYPE'] != 'STAR'
data = data[sel]
wz = data['Z_not4clus']*0 == 0
wz &= data['Z_not4clus'] != 999999
wz &= data['Z_not4clus'] != 1.e20
print(len(data),len(wz),np.sum(wz))
data['q'] = wz
cats.append(data)
if len(cats) == 1:
cat = cats[0]
cat['EFFTIME_ELG'] = 8.60 * cat['TSNR2_ELG']
cat['EFFTIME_QSO'] = 8.60/0.255 * cat['TSNR2_QSO']
cat['EFFTIME_LRG'] = 12.15 * cat['TSNR2_LRG']
cat['zfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_Z']) - 1.211 * cat['EBV']
cat['FIBERFLUX_Z_EC'] = cat['FIBERFLUX_Z']*10**(0.4*1.211*cat['EBV'])
gextc = 3.214
cat['gfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_G']) - gextc * cat['EBV']
cat['FIBERFLUX_G_EC'] = cat['FIBERFLUX_G']*10**(0.4*gextc*cat['EBV'])
rextc = 2.165
cat['rfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_R']) - rextc * cat['EBV']
cat['FIBERFLUX_R_EC'] = cat['FIBERFLUX_R']*10**(0.4*rextc*cat['EBV'])
cat['qf'] = np.array(cat['q'], dtype=float)
return cat
def get_ELG_data(specrel='fuji',tr='ELG_LOP',maskbits=[1,11,12,13],notqso=True):
maintids = fitsio.read('/global/cfs/cdirs/desi/survey/catalogs/main/LSS/'+tr+'targetsDR9v1.1.1.fits',columns=['TARGETID','DESI_TARGET','MASKBITS','NOBS_G','NOBS_R','NOBS_Z'])
maintids = common.cutphotmask(maintids,maskbits)
elgcatdir = '/global/cfs/cdirs/desi/users/raichoor/spectro/'+specrel
sv3 = fitsio.read(elgcatdir+'/sv3-elg-fuji-tiles.fits',columns=elgcol)
st = []
for i in range(0,len(sv3)):
st.append(sv3['SUBSET'][i][:4])
st = np.array(st)
wg = st == "thru"
sv3 = sv3[wg]
if tr != 'ELG':
print('cutting SV3 to main '+tr)
sel = sv3[tr] == True
print('length before is '+str(len(sv3)))
sv3 = sv3[sel]
print('length after is '+str(len(sv3)))
sel = sv3['PRIORITY'] > 10000
sv3 = sv3[sel]
print('length after cutting to priority > 10000 '+str(len(sv3)))
sv3 = ELG_goodobs(Table(sv3))
sv3 = join(sv3,maintids,keys=['TARGETID'])
print('length after join to main targets to get DESI_TARGET and cut on maskbits values '+str(len(sv3)))
elgcatdirg = '/global/cfs/cdirs/desi/users/raichoor/spectro/guadalupe'
main = fitsio.read(elgcatdirg+'/main-elg-guadalupe-tiles.fits',columns=elgcol)
st = []
for i in range(0,len(main)):
st.append(main['SUBSET'][i][:4])
st = np.array(st)
wg = st == "thru"
main = main[wg]
if tr != 'ELG':
print('cutting main to main '+tr)
sel = main[tr] == True
print('length before is '+str(len(main)))
main = main[sel]
print('length after is '+str(len(main)))
main = ELG_goodobs(Table(main))
main = join(main,maintids,keys=['TARGETID'])
print('length after join to main targets to get DESI_TARGET and cut on maskbits values '+str(len(main)))
sv1 = fitsio.read(elgcatdir+'/sv1-elg-fuji-tiles.fits',columns=elgcol)
if tr != 'ELG':
print('cutting SV1 to main '+tr)
sel = sv1[tr] == True
print('length before is '+str(len(sv1)))
sv1 = sv1[sel]
print('length after is '+str(len(sv1)))
sv1 = ELG_goodobs(Table(sv1))
sv1 = join(sv1,maintids,keys=['TARGETID'])
print('length after join to main targets to get DESI_TARGET and cut on maskbits values '+str(len(sv1)))
#cat = vstack([sv1, sv3, main], join_type='inner')
#cat = vstack([sv1, main], join_type='inner')
cat = main
print(len(cat))
if notqso:
# Remove QSO targets
mask = cat['DESI_TARGET'] & 2**2 ==0
print(' Remove QSO targets', np.sum(mask), np.sum(~mask), np.sum(~mask)/len(mask))
cat = cat[mask]
cat['EFFTIME_ELG'] = 8.60 * cat['TSNR2_ELG']
cat['EFFTIME_LRG'] = 12.15 * cat['TSNR2_LRG']
cat['zfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_Z']) - 1.211 * cat['EBV']
cat['FIBERFLUX_Z_EC'] = cat['FIBERFLUX_Z']*10**(0.4*1.211*cat['EBV'])
gextc = 3.214
cat['gfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_G']) - gextc * cat['EBV']
cat['FIBERFLUX_G_EC'] = cat['FIBERFLUX_G']*10**(0.4*gextc*cat['EBV'])
rextc = 2.165
cat['rfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_R']) - rextc * cat['EBV']
cat['FIBERFLUX_R_EC'] = cat['FIBERFLUX_R']*10**(0.4*rextc*cat['EBV'])
cat['qf'] = np.array(cat['q'], dtype=float)
return cat
def get_LRG_data(specrel='fuji'):
maintids = fitsio.read('/global/cfs/cdirs/desi/survey/catalogs/main/LSS/LRGtargetsDR9v1.1.1.fits',columns=['TARGETID','lrg_mask'])
sel = maintids['lrg_mask'] == 0
maintids = maintids[sel]
zcatdir = '/global/cfs/cdirs/desi/spectro/redux/'+specrel+'/zcatalog/'
perexpall = Table(fitsio.read(zcatdir+'ztile-sv1-dark-perexp.fits'))
sel = np.isin(perexpall['TARGETID'],maintids['TARGETID'])
perexplrg = perexpall[sel]
del perexpall
perexplrg = LRG_goodobs(perexplrg,'COADD_FIBERSTATUS','SV1_DESI_TARGET')
cat_1xall = Table(fitsio.read(zcatdir+'ztile-sv1-dark-1x_depth.fits'))
sel = np.isin(cat_1xall['TARGETID'],maintids['TARGETID'])
cat_1xlrg = cat_1xall[sel]
del cat_1xall
cat_1xlrg = LRG_goodobs(cat_1xlrg,'COADD_FIBERSTATUS','SV1_DESI_TARGET')
cat_deepall = Table(fitsio.read(zcatdir+'ztile-sv1-dark-cumulative.fits'))
sel = np.isin(cat_deepall['TARGETID'],maintids['TARGETID'])
cat_deeplrg = cat_deepall[sel]
del cat_deepall
cat_deeplrg = LRG_goodobs(cat_deeplrg,'COADD_FIBERSTATUS','SV1_DESI_TARGET')
cat_sv3all = Table(fitsio.read(zcatdir+'ztile-sv3-dark-cumulative.fits'))
sel = np.isin(cat_sv3all['TARGETID'],maintids['TARGETID'])
sel &= cat_sv3all['PRIORITY'] == 103200 #we don't want to include the failed repeats in the statistics
cat_sv3lrg = cat_sv3all[sel]
del cat_sv3all
cat_sv3lrg = LRG_goodobs(cat_sv3lrg,'COADD_FIBERSTATUS','SV3_DESI_TARGET')
if specrel == 'fuji':
specrelmain = 'guadalupe'
zcatdirm = '/global/cfs/cdirs/desi/spectro/redux/'+specrelmain+'/zcatalog/'
cat_mainall = Table(fitsio.read(zcatdirm+'ztile-main-dark-cumulative.fits'))
sel = np.isin(cat_mainall['TARGETID'],maintids['TARGETID'])
cat_mainlrg = cat_mainall[sel]
del cat_mainall
cat_mainlrg = LRG_goodobs(cat_mainlrg,'COADD_FIBERSTATUS','DESI_TARGET')
cat = vstack([perexplrg, cat_1xlrg, cat_mainlrg, cat_deeplrg, cat_sv3lrg], join_type='inner')
print(len(cat))
cat['EFFTIME_ELG'] = 8.60 * cat['TSNR2_ELG']
cat['EFFTIME_LRG'] = 12.15 * cat['TSNR2_LRG']
cat['zfibermag'] = 22.5 - 2.5*np.log10(cat['FIBERFLUX_Z']) - 1.211 * cat['EBV']
cat['FIBERFLUX_Z_EC'] = cat['FIBERFLUX_Z']*10**(0.4*1.211*cat['EBV'])
cat['qf'] = np.array(cat['q'], dtype=float)
return cat
def fit_cons(dl,el,minv=0,step=0.01):
c = minv
newcost = np.sum((dl-c)**2./el**2.)
oldcost = newcost + 1
while newcost < oldcost:
oc = c
oldcost = newcost
c += step
newcost = np.sum((dl-c)**2./el**2.)
return oldcost,c
class LRG_ssr:
def __init__(self,specrel='fuji',efftime_min=500,efftime_max=2000):
self.cat = get_LRG_data(specrel)
mask = self.cat['EFFTIME_LRG']>efftime_min
mask &= self.cat['EFFTIME_LRG']<efftime_max
self.cat = self.cat[mask]
def cost(self,q_predict):
return np.sum((self.cat['qf']-q_predict)**2)
def wrapper(self,params):
q_predict = 1-self.failure_rate(self.cat['FIBERFLUX_Z_EC'], self.cat['EFFTIME_LRG'], *params)
return self.cost(q_predict)
def failure_rate(self,flux, efftime, a, b, c):
sn = flux * np.sqrt(efftime)
return np.clip(np.exp(-(sn+a)/b)+c/flux, 0, 1)
def add_modpre(self,data):
res = minimize(self.wrapper, [0, 10., 0.01], bounds=((-200, 200), (0, 100), (0., 1)),
method='Powell', tol=1e-6)
pars = res.x
print(pars)
dflux = data['FIBERFLUX_Z']*10**(0.4*1.211*data['EBV'])#data['FIBERFLUX_Z_EC']
deff = 12.15 * data['TSNR2_LRG']#data['EFFTIME_LRG']
data['mod_success_rate'] = 1. -self.failure_rate(dflux,deff,*pars)
return data
class BGS_ssr:
def __init__(self,specrel='fuji',efftime_min=100,efftime_max=300):
self.cat = get_BGS_data_full('BGS_BRIGHT')
mask = self.cat['EFFTIME_BGS']>efftime_min
mask &= self.cat['EFFTIME_BGS']<efftime_max
self.cat = self.cat[mask]
self.selgz = self.cat['q'] == 1
ha,bine = np.histogram(self.cat['EFFTIME_BGS'])
hf,_ = np.histogram(self.cat['EFFTIME_BGS'][~self.selgz])
self.nzf = hf/ha
print(self.nzf)
self.nzfe = np.sqrt(hf)/ha
bc = []
bs = bine[1]-bine[0]
for i in range(0,len(bine)-1):
bc.append(bine[i]+bs/2.)
self.bc = np.array(bc)
self.bine = bine
def cost(self,q_predict):
return np.sum((self.cat['qf']-q_predict)**2)
def wrapper(self,params):
q_predict = 1-self.failure_rate(self.cat['FIBERFLUX_R_EC'], self.cat['EFFTIME_BGS'], *params)
return self.cost(q_predict)
def failure_rate(self,flux, efftime, a, b, c):
sn = flux * np.sqrt(efftime)
return np.clip(np.exp(-(sn+a)/b)+c/flux, 0, .5)
def add_modpre(self,data):
res = minimize(self.wrapper, [0, 10., 0.01], bounds=((-200, 200), (0, 100), (0., 1)),
method='Powell', tol=1e-6)
pars = res.x
print(pars,self.wrapper(pars))
dflux = data['FIBERFLUX_R']*10**(0.4*2.165*data['EBV'])#data['FIBERFLUX_Z_EC']
deff = 12.15/89.8 * data['TSNR2_BGS']#data['EFFTIME_LRG']
data['mod_success_rate'] = 1. -self.failure_rate(dflux,deff,*pars)
#print(len(data),np.sum(data['mod_success_rate']))
ha,_ = np.histogram(deff,bins=self.bine)
gz = data['ZWARN'] == 0
gz &= data['DELTACHI2'] > 40
hf,_ = np.histogram(deff[gz],weights=1/data[gz]['mod_success_rate'],bins=self.bine)
plt.errorbar(self.bc,1.-self.nzf,self.nzfe,fmt='ko')
plt.errorbar(self.bc,hf/ha,self.nzfe,fmt='rd')
plt.show()
return data
class ELG_ssr:
def __init__(self,specrel='fuji',efftime_min=450,efftime_max=1500):
self.cat = get_ELG_data_full('ELG_LOPnotqso')#get_ELG_data(specrel)
mask = self.cat['EFFTIME_ELG']>efftime_min
mask &= self.cat['EFFTIME_ELG']<efftime_max
self.cat = self.cat[mask]
self.selgz = self.cat['q'] == 1
ha,bine = np.histogram(self.cat['EFFTIME_ELG'])
hf,_ = np.histogram(self.cat['EFFTIME_ELG'][~self.selgz])
self.nzf = hf/ha
print(self.nzf)
self.nzfe = np.sqrt(hf)/ha
bc = []
bs = bine[1]-bine[0]
for i in range(0,len(bine)-1):
bc.append(bine[i]+bs/2.)
self.bc = np.array(bc)
self.bine = bine
self.vis_5hist = False
def cost(self,q_predict):
return np.sum((self.cat['qf']-q_predict)**2)
def wrapper(self,params):
q_predict = 1-self.failure_rate(self.cat['FIBERFLUX_G_EC'], self.cat['EFFTIME_ELG'], *params)
return self.cost(q_predict)
def wrapper_hist(self,params):
h_predict = self.failure_rate_eff(self.bc, *params)
diff = self.nzf-h_predict
cost = np.sum((diff/self.nzfe)**2.)
return cost
def failure_rate(self,flux, efftime, a, b, c):
#sn = flux * np.sqrt(efftime)
#return np.clip(np.exp(-(sn+a)/b)+c/flux, 0, 1)
return np.clip(np.exp(-(efftime+a)/b)+c/flux, 0, 1)
def failure_rate_eff(self, efftime, a, b, c):
#sn = flux * np.sqrt(efftime)
#return np.clip(np.exp(-(sn+a)/b)+c/flux, 0, 1)
return np.clip(np.exp(-(efftime+a)/b)+c, 0, 1)
def hist_norm(self,fluxc):
nzfper = []
consl = []
nb = 5
pstep = 100//5
costt = 0
for i in range(0,nb):
sel = self.cat['FIBERFLUX_G_EC'] > np.percentile(self.cat['FIBERFLUX_G_EC'],i*pstep)
sel &= self.cat['FIBERFLUX_G_EC'] < np.percentile(self.cat['FIBERFLUX_G_EC'],(i+1)*pstep)
mf = np.median(self.cat['FIBERFLUX_G_EC'][sel])
if self.vis_5hist:
print(mf)
#fper.append(mf)
wtf = (fluxc*(self.mft-self.cat['FIBERFLUX_G_EC'])/self.mft+1)*(self.wts_fid-1)+1
selw = wtf < 1
wtf[selw] = 1
ha,_ = np.histogram(self.cat['EFFTIME_ELG'][sel],bins=self.bine)
hf,_ = np.histogram(self.cat['EFFTIME_ELG'][sel&self.selgz],weights=wtf[sel&self.selgz],bins=self.bine)
#if self.vis_5hist:
# print(mf)
# print(np.sum(ha))
# print(np.sum(hf))
dl = hf/ha
nzfper.append(dl)
def ccost(c):
return np.sum((dl-c)**2./self.nzfpere[i]**2.)
resc = minimize(ccost, np.ones(1))
bc = resc.x
cost = ccost(bc)
consl.append(bc)
costt += cost
if self.vis_5hist:
for i in range(0,nb):
plt.errorbar(self.bc,nzfper[i],self.nzfpere[i])
plt.plot(self.bc,np.ones(len(self.bc))*consl[i],'k:')
plt.show()
return costt
def add_modpre(self,data):
res = minimize(self.wrapper_hist, [-200, 10., 0.01], bounds=((-10000, 0), (0, 10000), (0., 1)),
method='Powell', tol=1e-6)
pars = res.x
print(pars,self.wrapper_hist(pars))
gextc = 3.214
dflux = data['FIBERFLUX_G']*10**(0.4*gextc*data['EBV']) #data['FIBERFLUX_G_EC']
deff = 8.60 * data['TSNR2_ELG']#data['EFFTIME_ELG']
#data['mod_success_rate'] = 1. -self.failure_rate(dflux,deff,*pars)
data['mod_success_rate'] = 1. -self.failure_rate_eff(deff,*pars)
assr = 1. -self.failure_rate_eff(self.cat['EFFTIME_ELG'],*pars)
relssr = assr/np.max(assr)
drelssr = data['mod_success_rate']/np.max(assr)#np.max(data['mod_success_rate'])
seld = deff > 450
seld &= deff < 1500
print(len(relssr),len(drelssr[seld]),np.max(assr),np.max(data[seld]['mod_success_rate']))
self.wts_fid = 1/relssr
nzfper = []
nzfpere = []
fper = []
self.mft = np.median(self.cat['FIBERFLUX_G_EC'])
nb = 5
pstep = 100//5
for i in range(0,nb):
sel = self.cat['FIBERFLUX_G_EC'] > np.percentile(self.cat['FIBERFLUX_G_EC'],i*pstep)
sel &= self.cat['FIBERFLUX_G_EC'] < np.percentile(self.cat['FIBERFLUX_G_EC'],(i+1)*pstep)
mf = np.median(self.cat['FIBERFLUX_G_EC'][sel])
fper.append(mf)
ha,_ = np.histogram(self.cat['EFFTIME_ELG'][sel],bins=self.bine)
hf,_ = np.histogram(self.cat['EFFTIME_ELG'][sel&self.selgz],bins=self.bine)
hfw,_ = np.histogram(self.cat['EFFTIME_ELG'][sel&self.selgz],weights=self.wts_fid[sel&self.selgz],bins=self.bine)
nzfper.append(hf/ha)
nzfpere.append(np.sqrt(ha-hf)/ha)
#plt.plot(self.bc,hfw/ha)
#plt.title('inputs')
#plt.show()
self.nzfpere = nzfpere
rest = minimize(self.hist_norm, np.ones(1))#, bounds=((-10, 10)),
#method='Powell', tol=1e-6)
fcoeff = rest.x
self.vis_5hist = True
print(fcoeff,self.hist_norm(fcoeff))#,self.hist_norm(0.),self.hist_norm(1.))
wtf = (fcoeff*(self.mft-dflux)/self.mft+1)*(1/drelssr-1)+1
sel = wtf < 1
wtf[sel] = 1
data['WEIGHT_ZFAIL'] = wtf
return data
# nb = 5
# pstep = 100//5
# costt = 0
#
# seld = np.ones(len(dflux),dtype='bool')
# dflux = dflux[seld]
# deff =deff[seld]
# dselgz = data[seld]['o2c'] > 0.9
# wtf = (1/drelssr[seld]-1)+1
#print('are weight arrays equal?',np.array_equal(self.wts_fid,wtf))
# for i in range(0,nb):
# sel = dflux > np.percentile(dflux,i*pstep)
# sel &= dflux < np.percentile(dflux,(i+1)*pstep)
# mf = np.median(dflux[sel])
#
#
#
# ha,_ = np.histogram(deff[sel],bins=self.bine)
# hf,_ = np.histogram(deff[sel&dselgz],weights=wtf[sel&dselgz],bins=self.bine)
class QSO_ssr:
def __init__(self,specrel='fuji',efftime_min=450,efftime_max=1500):
self.cat = get_QSO_data_full('QSO')#get_ELG_data(specrel)
mask = self.cat['EFFTIME_QSO']>efftime_min
mask &= self.cat['EFFTIME_QSO']<efftime_max
self.cat = self.cat[mask]
self.selgz = self.cat['q'] == 1
ha,bine = np.histogram(self.cat['EFFTIME_QSO'])
hf,_ = np.histogram(self.cat['EFFTIME_QSO'][~self.selgz])
self.nzf = hf/ha
print(self.nzf)
self.nzfe = | np.sqrt(hf) | numpy.sqrt |
# 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])
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([1,-1,1])
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([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,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,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([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([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([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([3,3,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,3,1])
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,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([3,3,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([3,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([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([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([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([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,1,-1])
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([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,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,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([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([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(203, 'F d -3 :2', transformations)
space_groups[203] = sg
space_groups['F d -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([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))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
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(204, 'I m -3', transformations)
space_groups[204] = sg
space_groups['I 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,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))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_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(205, 'P a -3', transformations)
space_groups[205] = sg
space_groups['P a -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([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))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
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,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(206, 'I a -3', transformations)
space_groups[206] = sg
space_groups['I a -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([1,0,0,0,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_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([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_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,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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))
sg = SpaceGroup(207, 'P 4 3 2', transformations)
space_groups[207] = sg
space_groups['P 4 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([1,0,0,0,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,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([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([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([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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))
sg = SpaceGroup(208, 'P 42 3 2', transformations)
space_groups[208] = sg
space_groups['P 42 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([1,0,0,0,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_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([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_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,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([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,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,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([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([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([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([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,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,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([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([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([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
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,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,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([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([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([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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))
sg = SpaceGroup(209, 'F 4 3 2', transformations)
space_groups[209] = sg
space_groups['F 4 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([1,0,0,0,0,-1,0,1,0])
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,0,1,0,-1,0])
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,0,1,0,1,0,-1,0,0])
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,0,-1,0,1,0,1,0,0])
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([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,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([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([0,0,1,0,-1,0,1,0,0])
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,0,-1,0,-1,0,-1,0,0])
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,0,1,0,1,0])
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,0,-1,0,-1,0])
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,0,-1,0,1,0])
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,0,1,0,-1,0])
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,0,1,0,1,0,-1,0,0])
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,0,-1,0,1,0,1,0,0])
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,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,3,3])
trans_den = N.array([4,4,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([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([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,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
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,0,-1,0,-1,0,-1,0,0])
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,0,1,0,1,0])
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,0,-1,0,-1,0])
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,0,-1,0,1,0])
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,0,1,0,-1,0])
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([0,0,1,0,1,0,-1,0,0])
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([0,0,-1,0,1,0,1,0,0])
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([0,-1,0,1,0,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([0,1,0,-1,0,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([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([0,1,0,1,0,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([0,-1,0,-1,0,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([0,0,1,0,-1,0,1,0,0])
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([0,0,-1,0,-1,0,-1,0,0])
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,0,1,0,1,0])
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,0,-1,0,-1,0])
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,0,-1,0,1,0])
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,0,1,0,-1,0])
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([0,0,1,0,1,0,-1,0,0])
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([0,0,-1,0,1,0,1,0,0])
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([0,-1,0,1,0,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([0,1,0,-1,0,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([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([0,1,0,1,0,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([0,-1,0,-1,0,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([0,0,1,0,-1,0,1,0,0])
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([0,0,-1,0,-1,0,-1,0,0])
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,0,1,0,1,0])
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,0,-1,0,-1,0])
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(210, 'F 41 3 2', transformations)
space_groups[210] = sg
space_groups['F 41 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([1,0,0,0,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_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([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_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,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
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,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,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([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))
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([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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))
sg = SpaceGroup(211, 'I 4 3 2', transformations)
space_groups[211] = sg
space_groups['I 4 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([1,0,0,0,0,-1,0,1,0])
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,0,1,0,-1,0])
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,0,1,0,1,0,-1,0,0])
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,0,-1,0,1,0,1,0,0])
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([0,-1,0,1,0,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([0,1,0,-1,0,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([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))
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([0,0,1,0,-1,0,1,0,0])
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([0,0,-1,0,-1,0,-1,0,0])
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,0,1,0,1,0])
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,0,-1,0,-1,0])
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(212, 'P 43 3 2', transformations)
space_groups[212] = sg
space_groups['P 43 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([1,0,0,0,0,-1,0,1,0])
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,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
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,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([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))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,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([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
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([0,0,-1,0,-1,0,-1,0,0])
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,0,1,0,1,0])
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([-1,0,0,0,0,-1,0,-1,0])
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))
sg = SpaceGroup(213, 'P 41 3 2', transformations)
space_groups[213] = sg
space_groups['P 41 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([1,0,0,0,0,-1,0,1,0])
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,0,1,0,-1,0])
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,0,1,0,1,0,-1,0,0])
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,0,-1,0,1,0,1,0,0])
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,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([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([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([0,0,1,0,-1,0,1,0,0])
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([0,0,-1,0,-1,0,-1,0,0])
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,0,1,0,1,0])
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([-1,0,0,0,0,-1,0,-1,0])
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,0,-1,0,1,0])
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,0,1,0,-1,0])
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,0,1,0,1,0,-1,0,0])
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,0,-1,0,1,0,1,0,0])
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,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([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))
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([0,0,1,0,-1,0,1,0,0])
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([0,0,-1,0,-1,0,-1,0,0])
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,0,1,0,1,0])
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([-1,0,0,0,0,-1,0,-1,0])
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))
sg = SpaceGroup(214, 'I 41 3 2', transformations)
space_groups[214] = sg
space_groups['I 41 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([-1,0,0,0,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_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([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_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,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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))
sg = SpaceGroup(215, 'P -4 3 m', transformations)
space_groups[215] = sg
space_groups['P -4 3 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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_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([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_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,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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([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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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([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([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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([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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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([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([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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([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([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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))
sg = SpaceGroup(216, 'F -4 3 m', transformations)
space_groups[216] = sg
space_groups['F -4 3 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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_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([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_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,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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))
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([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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))
sg = SpaceGroup(217, 'I -4 3 m', transformations)
space_groups[217] = sg
space_groups['I -4 3 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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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([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([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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))
sg = SpaceGroup(218, 'P -4 3 n', transformations)
space_groups[218] = sg
space_groups['P -4 3 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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,-1,0,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,0,-1,0,-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,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([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,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([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([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-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,0,1,0,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([1,0,0,0,0,-1,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([1,0,0,0,0,1,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([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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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([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([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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([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,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,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([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([1,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([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,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([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,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,0,1,0,-1,0])
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,0,-1,0,1,0])
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([0,0,-1,0,-1,0,1,0,0])
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([0,0,1,0,-1,0,-1,0,0])
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([0,1,0,-1,0,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([0,-1,0,1,0,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([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([0,-1,0,-1,0,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([0,1,0,1,0,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([0,0,-1,0,1,0,-1,0,0])
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([0,0,1,0,1,0,1,0,0])
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,0,-1,0,-1,0])
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,0,1,0,1,0])
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))
sg = SpaceGroup(219, 'F -4 3 c', transformations)
space_groups[219] = sg
space_groups['F -4 3 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,0,0,0,0,1,0,-1,0])
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,0,-1,0,1,0])
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,0,-1,0,-1,0,1,0,0])
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,0,1,0,-1,0,-1,0,0])
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,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([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([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([0,0,-1,0,1,0,-1,0,0])
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([0,0,1,0,1,0,1,0,0])
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,0,-1,0,-1,0])
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([1,0,0,0,0,1,0,1,0])
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,0,1,0,-1,0])
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,0,-1,0,1,0])
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,0,-1,0,-1,0,1,0,0])
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,0,1,0,-1,0,-1,0,0])
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,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([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))
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([0,0,-1,0,1,0,-1,0,0])
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([0,0,1,0,1,0,1,0,0])
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,0,-1,0,-1,0])
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([1,0,0,0,0,1,0,1,0])
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))
sg = SpaceGroup(220, 'I -4 3 d', transformations)
space_groups[220] = sg
space_groups['I -4 3 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([1,0,0,0,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_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([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_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,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_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([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_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,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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))
sg = SpaceGroup(221, 'P m -3 m', transformations)
space_groups[221] = sg
space_groups['P m -3 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,0,-1,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([1,0,0,0,0,1,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,0,1,0,1,0,-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([0,0,-1,0,1,0,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,-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([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([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([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,-1,0,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([0,0,1,0,-1,0,-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,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([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([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([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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))
sg = SpaceGroup(222, 'P n -3 n :2', transformations)
space_groups[222] = sg
space_groups['P n -3 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,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,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([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([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([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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([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([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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))
sg = SpaceGroup(223, 'P m -3 n', transformations)
space_groups[223] = sg
space_groups['P m -3 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,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,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([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([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([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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([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([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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))
sg = SpaceGroup(224, 'P n -3 m :2', transformations)
space_groups[224] = sg
space_groups['P n -3 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,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_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([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_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,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_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([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_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,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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([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,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,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([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([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([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([-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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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([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([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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([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,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,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([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([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([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([-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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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([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([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
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,0,-1,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([1,0,0,0,0,1,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,0,1,0,-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,0,1,0,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,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([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([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([0,0,1,0,-1,0,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,0,-1,0,-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,0,1,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([-1,0,0,0,0,-1,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([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
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,0,1,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([-1,0,0,0,0,-1,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,0,-1,0,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,0,-1,0,-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,-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([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([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([0,0,-1,0,1,0,-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,0,1,0,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,0,-1,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([1,0,0,0,0,1,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))
sg = SpaceGroup(225, 'F m -3 m', transformations)
space_groups[225] = sg
space_groups['F m -3 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,0,-1,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([1,0,0,0,0,1,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,0,1,0,1,0,-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,0,1,0,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,-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([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,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([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([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = | N.array([1,0,0]) | numpy.array |
"""
Interval unit commitment
@author:<NAME>
@e-mail:<EMAIL>
"""
from pypower import loadcase, ext2int, makeBdc
from scipy.sparse import csr_matrix as sparse
from numpy import zeros, c_, shape, ix_, ones, r_, arange, sum, concatenate, array, diag, eye
from solvers.mixed_integer_solvers_cplex import mixed_integer_linear_programming as lp
import pandas as pd
def problem_formulation(case, BETA=0.15, BETA_HYDRO=0.05, BETA_LOAD=0.03):
"""
:param case: The test case for unit commitment problem
:return:
"""
CAP_WIND = 1 # The capacity of wind farm
# The disturbance range of wind farm
# The disturbance range of wind farm
CAPVALUE = 10 # The capacity value
Price_energy = r_[ones(8), 3 * ones(8), ones(8)]
from pypower.idx_brch import F_BUS, T_BUS, BR_X, TAP, SHIFT, BR_STATUS, RATE_A
from pypower.idx_cost import MODEL, NCOST, PW_LINEAR, COST, POLYNOMIAL
from pypower.idx_bus import BUS_TYPE, REF, VA, VM, PD, GS, VMAX, VMIN, BUS_I
from pypower.idx_gen import GEN_BUS, VG, PG, QG, PMAX, PMIN, QMAX, QMIN
mpc = ext2int.ext2int(case)
baseMVA, bus, gen, branch, gencost = mpc["baseMVA"], mpc["bus"], mpc["gen"], mpc["branch"], mpc["gencost"]
nb = shape(mpc['bus'])[0] ## number of buses
nl = shape(mpc['branch'])[0] ## number of branches
ng = shape(mpc['gen'])[0] ## number of dispatchable injections
# Bbus = makeBdc.makeBdc(baseMVA, bus, branch)
# Distribution_factor = Bbus[1] * inv(Bbus[0])
Distribution_factor = array([
[0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[-0.005, -0.005, -0.005, -1.005, -0.005, -0.005, -0.005, -0.005, -0.005, -0.005, -0.005, -0.005, -0.005,
-0.005, ],
[0.47, 0.47, 0.47, 0.47, -0.03, -0.03, -0.03, -0.03, -0.03, -0.03, -0.03, -0.03, -0.03, -0.03],
[0.47, 0.47, 0.47, 0.47, -0.03, - 0.03, -0.03, -0.03, -0.03, -0.03, -0.03, -0.03, -0.03, -0.03],
[0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0.32, 0.32, 0.32, 0.32, 0.32, 0.32, -0.68, -0.68, 0.32, 0.32, 0.32, 0.32, 0.32, 0.32],
[0.32, 0.32, 0.32, 0.32, 0.32, 0.32, 0.32, 0.32, -0.68, -0.68, 0.32, 0.32, 0.32, 0.32],
[0.16, 0.16, 0.16, 0.16, 0.16, 0.16, 0.16, 0.16, 0.16, -0.84, 0.16, 0.16, 0.16, 0.16],
[-0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -1.16, -0.16, -1.16, -0.16],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0],
[-0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -0.16, -1.16, -0.16, -0.16],
[-0.08, -0.08, -0.08, -0.08, -0.08, -0.08, -0.08, -0.08, -0.08, -0.08, -0.08, -0.08, -0.08, -1.08],
])
Distribution_factor = sparse(Distribution_factor)
# Formulate connection matrix for wind farms
i = []
PWMAX = []
PWMIN = []
for index in range(ng):
if gen[index, PMIN] == 0:
i.append(index)
PWMAX.append(gen[index, PMAX])
PWMIN.append(gen[index, PMIN])
i = array(i)
nw = i.shape[0]
Cw = sparse((ones(nw), (gen[i, GEN_BUS], arange(nw))), shape=(nb, nw))
PWMAX = array(PWMAX).reshape((len(PWMAX), 1))
PWMIN = array(PWMIN).reshape((len(PWMIN), 1))
# Formulate the connection matrix for hydro power plants
i = []
PHMAX = []
PHMIN = []
for index in range(ng):
if gen[index, PMIN] > 0:
i.append(index)
PHMAX.append(gen[index, PMAX])
PHMIN.append(gen[index, PMIN])
i = array(i)
nh = i.shape[0]
Ch = sparse((ones(nh), (gen[i, GEN_BUS], arange(nh))), shape=(nb, nh))
PHMAX = array(PHMAX).reshape((len(PHMAX), 1))
PHMIN = array(PHMIN).reshape((len(PHMIN), 1))
# Formulate the external power systems
i = []
PEXMAX = []
PEXMIN = []
for index in range(ng):
if gen[index, PMIN] < 0:
i.append(index)
PEXMAX.append(gen[index, PMAX])
PEXMIN.append(gen[index, PMIN])
i = array(i)
nex = i.shape[0]
Cex = sparse((ones(nex), (gen[i, GEN_BUS], arange(nex))), shape=(nb, nex))
PEXMAX = array(PEXMAX).reshape((len(PEXMAX), 1))
PEXMIN = array(PEXMIN).reshape((len(PEXMIN), 1))
PLMAX = branch[:, RATE_A].reshape((nl, 1)) # The power flow limitation
T = 24
## Profiles
# Wind profile
WIND_PROFILE = array(
[591.35, 714.50, 1074.49, 505.06, 692.78, 881.88, 858.48, 609.11, 559.95, 426.86, 394.54, 164.47, 27.15, 4.47,
54.08, 109.90, 111.50, 130.44, 111.59, 162.38, 188.16, 216.98, 102.94, 229.53]).reshape((T, 1))
WIND_PROFILE = WIND_PROFILE / WIND_PROFILE.max()
WIND_PROFILE_FORECAST = zeros((T * nw, 1))
Delta_wind = zeros((T * nw, 1))
for i in range(T):
WIND_PROFILE_FORECAST[i * nw:(i + 1) * nw, :] = WIND_PROFILE[i] * PWMAX
Delta_wind[i * nw:(i + 1) * nw, :] = WIND_PROFILE[i] * PWMAX * BETA
# Load profile
LOAD_PROFILE = array([0.632596195634005, 0.598783973523217, 0.580981513054525, 0.574328051348912, 0.584214221241601,
0.631074282084712, 0.708620833751212, 0.797665730618795, 0.877125330124026, 0.926981579915087,
0.947428654208872, 0.921588439808779, 0.884707317888543, 0.877717046100358, 0.880387289807107,
0.892056129442049, 0.909233443653261, 0.926748403704075, 0.968646575067696, 0.999358974358974,
0.979169591816267, 0.913517534182463, 0.806453715775750, 0.699930632166617]).reshape((T, 1))
LOAD_FORECAST = zeros((T * nb, 1))
Delta_load = zeros((T * nb, 1))
load_base = bus[:, PD].reshape(nb, 1)
for i in range(T):
LOAD_FORECAST[i * nb:(i + 1) * nb, :] = load_base * LOAD_PROFILE[i]
Delta_load[i * nb:(i + 1) * nb, :] = load_base * BETA_LOAD
# Hydro information
HYDRO_INJECT = array([6, 2, 4, 3]).reshape((nh, 1))
HYDRO_INJECT_FORECAST = zeros((T * nh, 1))
Delta_hydro = zeros((T * nh, 1))
for i in range(T):
HYDRO_INJECT_FORECAST[i * nh:(i + 1) * nh, :] = HYDRO_INJECT
Delta_hydro[i * nh:(i + 1) * nh, :] = HYDRO_INJECT * BETA_HYDRO
MIN_DOWN = ones((nh, 1))
MIN_UP = ones((nh, 1))
QMIN = array([1.5, 1, 1, 1]).reshape((nh, 1))
QMAX = array([20, 10, 10, 10]).reshape((nh, 1))
VMIN = array([70, 50, 70, 40]).reshape((nh, 1))
VMAX = array([160, 140, 150, 130]).reshape((nh, 1))
V0 = array([110, 90, 100, 80]).reshape((nh, 1))
M_transfer = diag(array([8.8649, 6.4444, 6.778, 7.3333]))
C_TEMP = array([30, 2, 9, 4]).reshape((4, 1))
Q_TEMP = array([1.5, 1, 1, 1]).reshape((4, 1))
# Define the first stage decision variables
ON = 0
OFF = 1
IHG = 2
PHG = 3
RUHG = 4
RDHG = 5
QHG = 6
QUHG = 7
QDHG = 8
V = 9
S = 10
PWC = 11
PLC = 12
PEX = 13
CEX = 14
NX = PWC * nh * T + nw * T + nb * T + nex * T + 1
lb = zeros((NX, 1))
ub = zeros((NX, 1))
c = zeros((NX, 1))
vtypes = ["c"] * NX
for i in range(T):
for j in range(nh):
# lower boundary information
lb[ON * nh * T + i * nh + j] = 0
lb[OFF * nh * T + i * nh + j] = 0
lb[IHG * nh * T + i * nh + j] = 0
lb[PHG * nh * T + i * nh + j] = 0
lb[RUHG * nh * T + i * nh + j] = 0
lb[RDHG * nh * T + i * nh + j] = 0
lb[QHG * nh * T + i * nh + j] = 0
lb[QUHG * nh * T + i * nh + j] = 0
lb[QDHG * nh * T + i * nh + j] = 0
lb[V * nh * T + i * nh + j] = VMIN[j]
lb[S * nh * T + i * nh + j] = 0
# upper boundary information
ub[ON * nh * T + i * nh + j] = 1
ub[OFF * nh * T + i * nh + j] = 1
ub[IHG * nh * T + i * nh + j] = 1
ub[PHG * nh * T + i * nh + j] = PHMAX[j]
ub[RUHG * nh * T + i * nh + j] = PHMAX[j]
ub[RDHG * nh * T + i * nh + j] = PHMAX[j]
ub[QHG * nh * T + i * nh + j] = QMAX[j]
ub[QUHG * nh * T + i * nh + j] = QMAX[j]
ub[QDHG * nh * T + i * nh + j] = QMAX[j]
ub[V * nh * T + i * nh + j] = VMAX[j]
ub[S * nh * T + i * nh + j] = 10 ** 8
# objective value
c[S * nh * T + i * nh + j] = 1
c[RUHG * nh * T + i * nh + j] = -Price_energy[j]
c[RDHG * nh * T + i * nh + j] = Price_energy[j]
# variables types
vtypes[ON * nh * T + i * nh + j] = "D"
vtypes[OFF * nh * T + i * nh + j] = "D"
vtypes[IHG * nh * T + i * nh + j] = "D"
if i == T - 1:
lb[V * nh * T + i * nh + j] = V0[j]
ub[V * nh * T + i * nh + j] = V0[j]
for j in range(nw):
# lower boundary information
lb[PWC * nh * T + i * nw + j] = 0
# upper boundary information
ub[PWC * nh * T + i * nw + j] = WIND_PROFILE_FORECAST[i * nw + j]
# objective value
c[PWC * nh * T + i * nw + j] = 1
for j in range(nb):
# lower boundary information
lb[PWC * nh * T + nw * T + i * nb + j] = 0
# upper boundary information
ub[PWC * nh * T + nw * T + i * nb + j] = bus[j, PD] * LOAD_PROFILE[i]
# objective value
c[PWC * nh * T + nw * T + i * nb + j] = 10 ** 8
for j in range(nex):
# lower boundary information
lb[PWC * nh * T + nw * T + nb * T + i * nex + j] = PEXMIN[j]
# upper boundary information
ub[PWC * nh * T + nw * T + nb * T + i * nex + j] = PEXMAX[j]
# objective value
c[PWC * nh * T + nw * T + nb * T + i * nex + j] = -Price_energy[i]
# lower boundary information
lb[PWC * nh * T + nw * T + nb * T + nex * T] = PEXMIN[0]
# upper boundary information
ub[PWC * nh * T + nw * T + nb * T + nex * T] = PEXMAX[0]
# objective value
# c[PWC * nh * T + nw * T + nb * T + nex * T] = -CAPVALUE
# 2) Constraint set
# 2.1) Power balance equation
Aeq = zeros((T, NX))
beq = zeros((T, 1))
for i in range(T):
# For the hydro units
for j in range(nh):
Aeq[i, PHG * nh * T + i * nh + j] = 1
# For the wind farms
for j in range(nw):
Aeq[i, PWC * nh * T + i * nw + j] = -1
# For the loads
for j in range(nb):
Aeq[i, PWC * nh * T + nw * T + i * nb + j] = 1
# For the power exchange
for j in range(nex):
Aeq[i, PWC * nh * T + nw * T + nb * T + i * nex + j] = -1
beq[i] = sum(load_base) * LOAD_PROFILE[i] - sum(WIND_PROFILE_FORECAST[i * nw:(i + 1) * nw])
# 2.2) Status transformation of each unit
Aeq_temp = zeros((T * nh, NX))
beq_temp = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aeq_temp[i * nh + j, ON * nh * T + i * nh + j] = -1
Aeq_temp[i * nh + j, OFF * nh * T + i * nh + j] = 1
Aeq_temp[i * nh + j, IHG * nh * T + i * nh + j] = 1
if i != 0:
Aeq_temp[i * nh + j, IHG * nh * T + (i - 1) * nh + j] = -1
else:
beq_temp[i * T + j] = 0
Aeq = concatenate((Aeq, Aeq_temp), axis=0)
beq = concatenate((beq, beq_temp), axis=0)
# 2.3) water status change
Aeq_temp = zeros((T * nh, NX))
beq_temp = HYDRO_INJECT_FORECAST
for i in range(T):
for j in range(nh):
Aeq_temp[i * nh + j, V * nh * T + i * nh + j] = 1
Aeq_temp[i * nh + j, S * nh * T + i * nh + j] = 1
Aeq_temp[i * nh + j, QHG * nh * T + i * nh + j] = 1
if i != 0:
Aeq_temp[i * nh + j, V * nh * T + (i - 1) * nh + j] = -1
else:
beq_temp[i * T + j] += V0[j]
Aeq = concatenate((Aeq, Aeq_temp), axis=0)
beq = concatenate((beq, beq_temp), axis=0)
# 2.4) Power water transfering
Aeq_temp = zeros((T * nh, NX))
beq_temp = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aeq_temp[i * nh + j, PHG * nh * T + i * nh + j] = 1
Aeq_temp[i * nh + j, QHG * nh * T + i * nh + j] = -M_transfer[j, j]
Aeq_temp[i * nh + j, IHG * nh * T + i * nh + j] = -C_TEMP[j] + M_transfer[j, j] * Q_TEMP[j]
Aeq = concatenate((Aeq, Aeq_temp), axis=0)
beq = concatenate((beq, beq_temp), axis=0)
# 2.5) Power range limitation
Aineq = zeros((T * nh, NX))
bineq = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aineq[i * nh + j, ON * nh * T + i * nh + j] = 1
Aineq[i * nh + j, OFF * nh * T + i * nh + j] = 1
bineq[i * nh + j] = 1
Aineq_temp = zeros((T * nh, NX))
bineq_temp = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aineq_temp[i * nh + j, IHG * nh * T + i * nh + j] = PHMIN[j]
Aineq_temp[i * nh + j, PHG * nh * T + i * nh + j] = -1
Aineq_temp[i * nh + j, RDHG * nh * T + i * nh + j] = 1
Aineq = concatenate((Aineq, Aineq_temp), axis=0)
bineq = concatenate((bineq, bineq_temp), axis=0)
Aineq_temp = zeros((T * nh, NX))
bineq_temp = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aineq_temp[i * nh + j, IHG * nh * T + i * nh + j] = -PHMAX[j]
Aineq_temp[i * nh + j, PHG * nh * T + i * nh + j] = 1
Aineq_temp[i * nh + j, RUHG * nh * T + i * nh + j] = 1
Aineq = concatenate((Aineq, Aineq_temp), axis=0)
bineq = concatenate((bineq, bineq_temp), axis=0)
# 2.6) Water reserve constraints
Aineq_temp = zeros((T * nh, NX))
bineq_temp = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aineq_temp[i * nh + j, PHG * nh * T + i * nh + j] = 1
Aineq_temp[i * nh + j, RUHG * nh * T + i * nh + j] = 1
Aineq_temp[i * nh + j, IHG * nh * T + i * nh + j] = -C_TEMP[j] + M_transfer[j, j] * Q_TEMP[j]
Aineq_temp[i * nh + j, QHG * nh * T + i * nh + j] = -M_transfer[j, j]
Aineq_temp[i * nh + j, QUHG * nh * T + i * nh + j] = -M_transfer[j, j]
Aineq = concatenate((Aineq, Aineq_temp), axis=0)
bineq = concatenate((bineq, bineq_temp), axis=0)
Aineq_temp = zeros((T * nh, NX))
bineq_temp = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aineq_temp[i * nh + j, PHG * nh * T + i * nh + j] = -1
Aineq_temp[i * nh + j, RDHG * nh * T + i * nh + j] = 1
Aineq_temp[i * nh + j, IHG * nh * T + i * nh + j] = C_TEMP[j] - M_transfer[j, j] * Q_TEMP[j]
Aineq_temp[i * nh + j, QHG * nh * T + i * nh + j] = M_transfer[j, j]
Aineq_temp[i * nh + j, QDHG * nh * T + i * nh + j] = -M_transfer[j, j]
Aineq = concatenate((Aineq, Aineq_temp), axis=0)
bineq = concatenate((bineq, bineq_temp), axis=0)
# 2.7) water flow constraints
Aineq_temp = zeros((T * nh, NX))
bineq_temp = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aineq_temp[i * nh + j, IHG * nh * T + i * nh + j] = QMIN[j]
Aineq_temp[i * nh + j, QHG * nh * T + i * nh + j] = -1
Aineq_temp[i * nh + j, QDHG * nh * T + i * nh + j] = 1
Aineq = concatenate((Aineq, Aineq_temp), axis=0)
bineq = concatenate((bineq, bineq_temp), axis=0)
Aineq_temp = zeros((T * nh, NX))
bineq_temp = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aineq_temp[i * nh + j, IHG * nh * T + i * nh + j] = -QMAX[j]
Aineq_temp[i * nh + j, QHG * nh * T + i * nh + j] = 1
Aineq_temp[i * nh + j, QUHG * nh * T + i * nh + j] = 1
Aineq = concatenate((Aineq, Aineq_temp), axis=0)
bineq = concatenate((bineq, bineq_temp), axis=0)
# 2.8) Water reserve limitation
Aineq_temp = zeros((T * nh, NX))
bineq_temp = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aineq_temp[i * nh + j, V * nh * T + i * nh + j] = 1
Aineq_temp[i * nh + j, QHG * nh * T + i * nh + j] = -1
Aineq_temp[i * nh + j, QDHG * nh * T + i * nh + j] = 1
Aineq_temp[i * nh + j, S * nh * T + i * nh + j] = -1
bineq_temp[i * nh + j] = VMAX[j] - HYDRO_INJECT_FORECAST[i * nh + j]
Aineq = concatenate((Aineq, Aineq_temp), axis=0)
bineq = concatenate((bineq, bineq_temp), axis=0)
Aineq_temp = zeros((T * nh, NX))
bineq_temp = zeros((T * nh, 1))
for i in range(T):
for j in range(nh):
Aineq_temp[i * nh + j, V * nh * T + i * nh + j] = -1
Aineq_temp[i * nh + j, QHG * nh * T + i * nh + j] = 1
Aineq_temp[i * nh + j, QUHG * nh * T + i * nh + j] = 1
Aineq_temp[i * nh + j, S * nh * T + i * nh + j] = 1
bineq_temp[i * nh + j] = -VMIN[j] + HYDRO_INJECT_FORECAST[i * nh + j]
Aineq = concatenate((Aineq, Aineq_temp), axis=0)
bineq = | concatenate((bineq, bineq_temp), axis=0) | numpy.concatenate |
# -*- coding: utf-8 -*-
"""
Created on Wed May 11 08:08:52 2016
@author: tkc
"""
import re
from collections import defaultdict
import pandas as pd
import numpy as np
import scipy
import scipy.stats
from scipy import optimize
from math import factorial # used by Savgol matrix
from scipy.optimize import curve_fit
#%%
def organizecolumns(df1,mycols):
''' Pass df and template (list of desired columns in desired order) and return reorganized newdf
'''
cols1=df1.columns.tolist()
newdf=df1 # avoids modification of passed df
uniquelist=[i for i in cols1 if i not in mycols]
for i,colname in enumerate(uniquelist): # remove cols from df1 that are absent from df2
# newdf.drop(colname, axis=1, inplace=True) # this modifies both passed and returned dfs
newdf=newdf.drop(colname, axis=1)
newdf=newdf[mycols] # reorder columns based on template df
return newdf
def parseelemlist(elemlist):
'''Find and separate multielement peaks to be averaged (e.g. Fe2 & Fe) from longer string of element peaks
e.g. splits "Mg Fe Fe2 Si" into "Mg Si" and "{Fe,[Fe,Fe2]} dictionary'''
# Strip numbers from strings within list
newlist=[re.match('\D+',i).group(0) for i in elemlist]
# find duplicated peaks (multiple peaks per element)
Multielem = defaultdict(list)
for i, item in enumerate(newlist):
Multielem[item].append(i)
Multielem = {k:v for k,v in Multielem.items() if len(v)>1} # dictionary with duplicated item and list with indices
duplist=list(Multielem.values()) # get list
duplist=[item for sublist in duplist for item in sublist] # single list with positions of duplicated elements
# now alter multipeak elements list to give dict with element and then list of peak for that element
for key,value in Multielem.items():
templist=value # dictionary value is list of elem peak index positions
peaklist=[]
for i, index in enumerate(templist): # create new list with original elem peak from index positions
peaklist.append(elemlist[index])
# now replace list of index positions with elempeak names
Multielem.update({key:peaklist}) # key will be multipeak element string i.e. "Fe"
# finally construct new single elements list with multipeak ones removed (handle each separately)
newelemlist=[]
for i in range(0,len(elemlist)):
if i not in duplist:
newelemlist.append(elemlist[i])
return newelemlist, Multielem
def parseelem2(elemlist, Multielem):
''' After multielement peaks removed, also move secondary peaks used as primary to dict (handle separately)
e.g. splits "S Mg Fe2 Si" into "S Mg Si" and "{Fe,[Fe2]} dictionary; same structure and df output
for averaging of Fe, Fe2, or straight Fe2 or straight Fe'''
# starting elemlist will only have single entries (i.e Ti2 but not Ti & Ti2)
newelemlist=[]
for i, elem in enumerate(elemlist):
if re.search(r'\d',elem): # has number
match=re.search(r'\d',elem)
newkey=elem[0:match.start()]
# store alt quant (i.e. on Ti2) with same structure as multiple quant (Ti & Ti2)
# Another entry in multielement list... makes things easier for later quant comparisons
templist=[] # peakIDs added as list (of length 1)
templist.append(elem) # list containing single string (keeps identical data structure)
Multielem.update({newkey:templist}) # add to existing dictionary for separate handling
else:
newelemlist.append(elemlist[i]) # just copy over
return newelemlist, Multielem # return altered element list and multielem dictionary
def getelemthresholds(elemlist, AESquantparams):
'''get element-dependent significance thresholds for each peak from AESquantparams
return dictionary with element and associated significance level'''
thresholds={} # returns list of element dependent thresholds for this element set
for i, elem in enumerate(elemlist):
# find row in AESquantparams for this element
thiselemdata=AESquantparams[(AESquantparams['element']==elem)]
thiselemdata=thiselemdata.squeeze() # series with this elements params
thresholds.update({elem:thiselemdata.siglevel})
return thresholds
def cloneparamrows(df):
''' Make param log entry for for each areanum - used by calccomposition to correctly process spe files with multiple spatial areas
passed df is usually list of spe files
this solves problem that AugerParamLog only has one entry (despite possibly having multiple distinct areas with different spectra'''
df['Areanumber']=1 # set existing entries as area 1
mycols=df.dtypes.index
newrows=pd.DataFrame(columns=mycols) # blank df for new entries
for index, row in df.iterrows():
numareas=int(df.loc[index]['Areas'])
for i in range(2,numareas+1):
newrow=df.loc[index] # clone this row as series
newrow=newrow.set_value('Areanumber',i)
newrows=newrows.append(newrow)
df=pd.concat([df,newrows], ignore_index=True) # merge new rows with existing ones
df=df.sort_values(['Filenumber','Areanumber'])
return df
def calccomp(df, Integquantlog, elemlist, AESquantparams):
'''Calculate elemental composition of given files based on input element list
threshold - ratio of element peak to noise peak (0 means no threshold applied
load element-dependent significance level from AESquantparams'''
thresholds=getelemthresholds(elemlist, AESquantparams) # Get list of sigma levels for significance/inclusion
# thresholds for both single and multipeak
elemlist, multipeaklist = parseelemlist(elemlist) # list of single peak elements and dict with multipeaks
# check if any of the single peaks are secondary (i.e. quant on Fe2 not main Fe)
elemlist, multipeaklist= parseelem2(elemlist, multipeaklist)
# two element lists needed (elements with one peak and elements with compositions averaged from two peaks i.e. Fe2, Fe3)
# to process compositions from multiple areas, clone rows from spe log (one for each areanum)
df=cloneparamrows(df) # splits single entry for 5 spatial area spe into 5 rows with Areanumber 1-5
df=df.reset_index(drop=True)
df['AESbasis']=0.0 # resets to zero if already present from calcamplitude
mycols=['Filenumber', 'Project', 'Filename', 'FilePath', 'Sample', 'Comments','AESbasis','Areanumber']
for i, elem in enumerate(elemlist): # add columns for basis
df[elem]=0.0 # add col for each element to spelist
df['sig'+elem]=0.0 # copy peak significance (ratio of integrated counts over 1 sigma of background)
df['err'+elem]=0.0 # another for total error in adjusted counts basis
mycols.append(elem)
mycols.append('sig'+elem)
mycols.append('err'+elem)
for i,elem in enumerate(list(multipeaklist.keys())): # get elements (keys) from dict
df[elem]=0.0
df['sig'+elem]=0.0
df['err'+elem]=0.0
mycols.append(elem)
mycols.append('sig'+elem)
mycols.append('err'+elem)
for i, elem in enumerate(elemlist): # now add at.% columns (e.g. %S, %Mg)
colname='%'+elem # at % columns named %S, %Mg, etc.
errname='err%'+elem
mycols.append(colname) # add to column list template
mycols.append(errname)
df[colname]=0.0
df[errname]=0.0
for i,elem in enumerate(list(multipeaklist.keys())): # add multipeak elements
colname='%'+elem # at % columns named %S, %Mg, etc.
errname='err%'+elem
mycols.append(colname) # add to column list template
mycols.append(errname)
df[colname]=0.0
df[errname]=0.0
for i in range(0,len(df)): # loop through all desired spectrum (multiarea ones already have duplicated rows)
filenum=df.iloc[i]['Filenumber']
areanum=df.iloc[i]['Areanumber']
match=Integquantlog[Integquantlog['Filenumber']==filenum] # find integ data for this filenumber
match=match[match['Areanumber']==areanum]
basis=0.0 #
for j, elem in enumerate(elemlist): # handle the single peak elements
temp=match[match['Element']==elem] # finds entry for this element
if len(temp)==1:
# thresholds is dict with required significance level for each element
thisthresh=thresholds.get(elem) # sig level for this element
df=df.set_value(i, 'sig'+elem, temp.iloc[0]['Significance']) # always copy peak significance level
if temp.iloc[0]['Significance']>thisthresh: # if above set threshold then calculate elem's value and add to basis
df=df.set_value(i, elem, temp.iloc[0]['Adjcnts']) # copy adjusted counts of this element
df=df.set_value(i, 'err'+elem, temp.iloc[0]['Erradjcnts'])
basis+=temp.iloc[0]['Adjcnts'] # add this element's value to AES basis
# now handle the multipeak elements (get average value from both peaks)
for key, value in multipeaklist.items(): # key is element (aka colname in df), value is list of peaks in Smdifpeakslog
templist=value # dictionary value is list of elem peak index positions
numlines=len(templist) # this is number of lines that are average (i.e. 2 for Fe&Fe2)
avgval=0.0 # working value for averaged adjamplitude
erravgval=0.0 # combined error from erradjcnts of each line
for k, peak in enumerate(templist): # create new list with original elem peak from index positions
temp=match[match['Element']==peak] # finds integquantlog entry for this peak (match already trimmed to filenum and area)
if len(temp)==1:
thisthresh=thresholds.get(peak) # sig level for this element/peak
df=df.set_value(i, 'sig'+elem, temp.iloc[0]['Significance']) # copy peak significance level
if temp.iloc[0]['Significance']>thisthresh:
avgval+=temp.iloc[0]['Adjcnts']
thiserrperc=temp.iloc[0]['Erradjcnts']/temp.iloc[0]['Adjcnts']**2
erravgval+=thiserrperc # sum of square of relative error
else:
numlines=numlines-1 # if peak is zeroed out and not added, this reduces # peaks in average
if numlines>0: # avoid divbyzero if peak is too small
avgval=avgval/numlines # this is now average basis for given element
erravgval=np.sqrt(erravgval) # sqrt of sum of squares is relative error
df=df.set_value(i, key, avgval) # copy adjusted amplitude of this element
df=df.set_value(i, key+'err', avgval*erravgval) # combined actual error of this elem (as detemined from mulitple lines)
# add value from this element to AESbasis
basis+=avgval
# end of multipeak elements loop
df=df.set_value(i, 'AESbasis', basis) # write total basis value to df
# Now compute at.% for each listed element (incl errors)
for j, elem in enumerate(elemlist):
colname='%'+elem
ratio=df.iloc[i][elem]/df.iloc[i]['AESbasis'] # initialized to zero in cases where peak is below significance threshold
df.set_value(i, colname, ratio)
temp=match[match['Element']==elem] # again find peak entry and get finds entry for this peak
# TODO maybe check threshold again (although element's value will be zero)
if len(temp)==1:
thiserr=temp.iloc[0]['Erradjcnts']
atpercerr=thiserr/df.iloc[i]['AESbasis']
errname='err%'+elem # error column
df.set_value(i, errname, atpercerr) # Writes absolute error in at%
# Also calculate for elements w/ multiple peaks (if present)
for key, value in multipeaklist.items():
templist=value # dictionary value is list of elem peak index positions
numlines=len(templist) # this is number of lines that are average (i.e. 2 for Fe&Fe2)
colname='%'+key
ratio=df.iloc[i][key]/df.iloc[i]['AESbasis']
df.set_value(i, colname, ratio)
# TODO need to propagate errors through Fe & Fe2
errlist=[] # list of errors in % (usually max of two)
for k, peak in enumerate(templist): # create new list with original elem peak from index positions
temp=match[match['Element']==peak] # finds entry for this peak
if len(temp)==1:
if temp.iloc[0]['Adjcnts']>0: # skip negative values
err=temp.iloc[0]['Erradjcnts']/temp.iloc[0]['Adjcnts']
errlist.append(err) # add this to list
# combine errors in quadrature
totalerr=0.0
for j, err in enumerate(errlist):
totalerr+=err**2
totalerr=np.sqrt(totalerr) # percent error in at %
# now get actual error
thisval=df.iloc[i][key] # this is averaged value computed above (possibly zero if below thresholds )
thiserr=thisval*totalerr # error (in Fe) as actual value based on average of multiple peaks
atpercerr=thiserr/df.iloc[i]['AESbasis']
errname='err%'+ key # error column
df.set_value(i, errname, atpercerr) # Writes absolute error in at%
# end of loop calculation for each spectrum
# organize data based on mycols template
df=organizecolumns(df,mycols)
return df
def calcadjcounts(df, AESquantparams, sig=2, kerrors=True):
'''For each elemental peak in interquantlog, calculate or recalcuated adjusted counts using k-factor2 and mass
result stored in adjcnts column and used for subsequent compositional determinations
can change AESquantresults and recalc at any time; sig (aka 2 sigma errors) is default setting
kerrors -- include error associated with kfactor (along with Poisson errors)'''
if 'Adjcnts' not in df:
df['Adjcnts']=0.0 # new column for adjusted amplitude (if not already present)
if 'Erradjcnts' not in df:
df['Erradjcnts']=0.0 # new column for associated error
if 'err%cnts' not in df:
df['err%cnts']=0.0 # percentage error only from counting statistics (not including kfactor err)
if 'err%total' not in df:
df['err%total']=0.0 # percentage error only from counting statistics (not including kfactor err)
# loop for each element, mask df, get appropriate k-factor & mass
df=df.reset_index(drop=True) # go ahead and reset index
elemlist=np.ndarray.tolist(df.Element.unique()) # list of unique elements from df
for i,elem in enumerate(elemlist):
match=AESquantparams[(AESquantparams['element']==elem)]
match=match.reset_index(drop=True)
kfactor2=match.iloc[0]['kfactor2'] # kfactor and mass for this element/peak
errkf2=match.iloc[0]['errkf2'] # percent error in above for integ method
mass=match.iloc[0]['mass']
elemmask=(df['Element']==elem) # mask for this element in loop
for j in range(0,len(df)): # loop and set adjamplitude to amp*kfact/mass
if elemmask[j]==True: # row has this element
newval=df.iloc[j]['Integcounts']*kfactor2/mass
percerr=sig/np.sqrt(df.iloc[j]['Integcounts']) # 2/sqrt(N) is percent error
totalerr= | np.sqrt(errkf2**2+percerr**2) | numpy.sqrt |
# 13 Nov 2018
from __future__ import print_function
import glob, os, json, sys
from PIL import Image
import numpy as np
import open3d
from collections import defaultdict
from data3d.indoor_data_util import random_sample_pcl
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
ROOT_DIR = os.path.dirname(os.path.dirname(BASE_DIR))
sys.path.append(BASE_DIR)
sys.path.append(ROOT_DIR)
USER_DIR = os.path.dirname(os.path.dirname(ROOT_DIR))
from wall_preprocessing import preprocess_walls
from window_preprocessing import preprocess_windows
from door_preprocessing import preprocess_doors
from celing_floor_room_preprocessing import preprocess_cfr
from utils3d.bbox3d_ops import Bbox3D
from data3d.dataset_metas import DSET_METAS0
from scene_samples import SceneSamples
Debug = True
FunctionUncomplemented = True
MIN_CAM_NUM = 10
MIN_POINT_NUM = 10000*10
ENABLE_NO_RECTANGLE = ['Ceiling', 'Floor', 'Room']
SAGE = True
ONLY_LEVEL_1 = True
SUNCG_V1_DIR = '/DS/SUNCG/suncg_v1'
PARSED_DIR_GOING = '_parsed_NewPcl__'
PARSED_DIR_READY = 'parsed_NewPcl'
#PARSED_PATH = f'{SUNCG_V1_DIR}/{PARSED_DIR_GOING}'
def show_pcl(pcl):
pcd = open3d.PointCloud()
pcd.points = open3d.Vector3dVector(pcl[:,0:3])
if pcl.shape[1] == 6:
pcd.colors = open3d.Vector3dVector(pcl[:,3:6])
open3d.draw_geometries([pcd])
def camPos2Extrinsics(cam_pos):
'''
cam:
ref:
https://github.com/shurans/SUNCGtoolbox/blob/master/gaps/apps/scn2cam/scn2cam.cpp Line207
vx, vy, vz, tx, ty, tz, ux, uy, uz, xf, yf, value
[vx, vy, vz] is the centroid
[tx,ty,tz] is cam forward orientation
[ux,uy,uz] is cam right orientation
value is the score of camera
xf: xfov yf:yfov
ref: https://github.com/shurans/sscnet/blob/master/matlab_code/utils/camPose2Extrinsics.m
cam_pos: [12]
'''
#cam_pos = np.array([38.2206 , 1.2672 , 41.8938 , 0.9785 , -0.1961 , -0.0644 , 0.1957, 0.9806 , -0.0129 , 0.5500 , 0.4310, 14.2487])
cam_pos = np.reshape(cam_pos, [12,1])
vv = cam_pos[0:3,:]
tv = cam_pos[3:6,:]
uv = cam_pos[6:9,:]
rv = np.reshape(np.cross(tv[:,0],uv[:,0]), [3,1])
extrinsics = np.concatenate([rv, -uv, tv, vv], 1)
# check R
R = extrinsics[0:3,0:3]
I = np.matmul(R, R.T)
assert np.sum( np.abs(np.diag(I)-1) ) < 1e-2
assert np.sum(np.abs(I- | np.eye(3) | numpy.eye |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Dec 9 00:54:57 2017
@author: scott
"""
import os
import re
import numpy as np
# import matplotlib as mpl
from scipy.interpolate import interp1d
from matplotlib import pyplot as plt
import time
import pickle
try:
from moviepy.editor import VideoClip
from moviepy.video.io.bindings import mplfig_to_npimage
except ImportError:
print("you need the package moviepy to be able to make movies!")
from .import_data import (
load_from_file,
read_macro,
epoch_time_to_timestamp,
timestamp_to_epoch_time,
)
from .pilatus import Pilatus, calibration_0, shape_0
from .XRD import integrate_peak, get_background_line, get_peak_background
from .XRD import Peak
timestamp_matcher = "([0-9]{2}\:){2}[0-9]{2}"
def get_images(
directory,
tag,
shape=shape_0,
calibration=calibration_0,
slits=True,
xslits=None,
yslits=[60, 430],
pixelmax=None,
verbose=True,
vverbose=False,
):
if verbose:
print("\n\nfunction 'get_images' at your service!\n")
try:
lslist = os.listdir(directory)
except FileNotFoundError:
print(
"The directory doesn't exist. get_images is returning a blank dictionary."
)
return {}
# print(tag) # debugging
if verbose:
print(str(len(lslist)) + " items in " + directory)
imagenames = [f for f in lslist if f[-4:] == ".raw" and tag in f]
if verbose:
print(
" of which "
+ str(len(imagenames))
+ " are image files including '"
+ tag
+ "'"
)
images = {}
for f in imagenames:
n = int(f[-8:-4]) # this is the image number as SPEC saves them
filepath = directory + os.sep + f
images[n] = Pilatus(
filepath,
shape=shape,
calibration=calibration,
slits=slits,
xslits=xslits,
yslits=yslits,
pixelmax=pixelmax,
verbose=vverbose,
)
if verbose:
print("\nfunction 'get_images' finished!\n\n")
return images
def peak_colors(peak_list, colors=["k", "b", "r", "g", "c", "m"]):
"""
This is a fill-in function until I've got some kind of standard colors
implemented. It takes a list of integral ranges and returns an identically
indexed dictionary with each value of the form (integral_range, color)
"""
integrals = {}
for i, integral in enumerate(peak_list):
integrals[i] = (integral, colors[i])
return integrals
def get_direction_mask(x, direction=True):
"""
Returns a mask selecting the values of x that are greater than (direction
= True) or less than (direction = False) all previous values
"""
if type(direction) in [int, float]:
direction = direction > 0
mask = []
X = x[0]
for x_i in x:
mask += [(x_i > X) == direction]
if mask[-1]:
X = x_i
return np.array(mask)
# ----------------- here comes the CLASS -----------------
class ScanImages:
# -------------- functions for defining the scan ----------
def __init__(
self,
name=None,
csvfile=None,
directory=None,
pilatusfilebase="default",
usecsv=True,
tag=None,
scan_type="time",
calibration=calibration_0,
macro=None,
tth=None,
alpha=None,
timestamp=None,
tstamp=None,
pixelmax=None,
timecol=None,
abstimecol=None,
tz=None,
slits=True,
xslits=None,
yslits=[60, 430],
scan=None,
copy=False,
load=False,
verbose=True,
vverbose=False,
):
"""
give EITHER a csvfile name with full path, or a directory and a tag.
pilatusfilebase can be constructed from this, and used to import the
Pilatus image objects.
The calibration is passed on to the Pilatus objects.
The macro is read to get the (tth, alpha) values which aren't scanned,
though they can also be put in manually.os.path.expanduser('~/o/FYSIK/list-SurfCat/setups/Synchrotron/May2018')
timestamp can be either a str like 'hh:mm:ss' or a pointer.
timestamp='abstimecol' uses the first value of the specified timecol in the csvfile
timestamp=None tries to get it from the file
"""
# ------- load a pickle, to save computing time and space -------- #
if load:
try:
with open(name, "rb") as f:
scan = pickle.load(f)
except FileNotFoundError:
print("Couldn't find " + name)
loadname = name + ".pkl"
print("Trying " + loadname + ".")
with open(loadname, "rb") as f:
scan = pickle.load(f)
print("Loaded " + name)
# ------ for development: new code with pre-loaded data -------#
if copy or load: # take all data (images, csv_data, etc) from another scan
for attr in dir(scan):
if attr not in dir(
self
): # because we don't want to replace e.g. functions
setattr(self, attr, getattr(scan, attr))
try:
self.copied += 1
except AttributeError:
self.copied = 1
return
# ---- parse inputs for name and, if csv used, csvname -----------------#
csvname = None
if usecsv:
if csvfile is None:
csv_directory = directory
# print(load) # debugging
if (tag is None or directory is None) and not load:
print("need a csv file name or a directory and a tag!")
return
lslist = os.listdir(directory)
try:
csvname = next(
f
for f in lslist
if f[-4:] == ".csv" and "_scan" in f and tag in f
)
except StopIteration:
if load:
pass
else:
print(lslist)
print(
"Cound not find a csvname containing "
+ tag
+ " in "
+ directory
+ "\n(ls above)"
)
else:
csv_directory, csvname = os.path.split(csvfile)
if len(csv_directory) == 0:
csv_directory = directory
if csvname is not None:
print(
"Loading Scan from directory = "
+ directory
+ "\n found csvname = "
+ str(csvname)
)
if name is None:
if tag is not None:
name = tag
elif csvname is not None:
name = csvname[:-4] # to drop the .csv
elif csvfile is not None:
name = csvfile
print("scan name = '" + name + "'")
# -------------- install easy metadata ------------- #
self.directory = directory
self.name = name
self.timecol = timecol
self.abstimecol = abstimecol
self.tz = tz
self.bg = False # stores whether background has been subtracted
self.verbose = verbose
self.vverbose = vverbose
if scan_type in ["time", "t"]:
self.scan_type = "t"
elif scan_type in ["tth", "TwoTheta"]:
self.scan_type = "tth"
elif scan_type in ["alpha", "a", "th", "Theta"]:
self.scan_type = "alpha"
if macro is not None:
self.macro = macro
self.settings = read_macro(macro)
if tth is None:
tth = self.settings["tth"][-1]
if alpha is None:
alpha = self.settings["alpha"][-1]
self.tth = tth
self.alpha = alpha
# try to read stuff from file name
if csvname is not None:
for match in re.findall("_[A-Za-z]+[n?][0-9]+[p[0-9]+]?", csvname):
attr = re.search("[A-Za-z]", match).group()
value = re.search("[0-9]+[n]?[p[0-9]+]?", match).group()
try:
value = float(value.replace("p", ".").replace("n", "-"))
except ValueError:
print("not sure what " + value + " is.")
if not hasattr(self, attr):
setattr(self, attr, value)
elif getattr(self, value) is None:
setattr(self, attr, value)
# --------- import csv if requested
if csvname is not None:
csvfilepath = csv_directory + os.sep + csvname
self.csv_data = load_from_file(
csvfilepath, data_type="SPEC", timestamp=timestamp, tstamp=tstamp, tz=tz
)
self.csvfilepath = csvfilepath
# -------------------- get images! ------------------------#
if pilatusfilebase == "default":
for foldername in ["images", "Pilatus"]:
pilatus_directory = directory + os.sep + foldername
if os.path.isdir(pilatus_directory):
break
else:
print("could not find pilatus directory!")
tag_pilatus = name
else:
pilatus_directory, tag_pilatus = os.path.split(pilatusfilebase)
self.images = get_images(
pilatus_directory,
tag=tag_pilatus,
calibration=calibration,
verbose=verbose,
pixelmax=pixelmax,
slits=slits,
xslits=xslits,
yslits=yslits,
vverbose=vverbose,
)
if len(self.images) == 0:
raise Warning("THIS SCAN IS EMPTY!!!!")
self.empty = True
return
else:
self.empty = False
# ------------------------- organize csvdata and metadata ---------- #
if hasattr(self, "csv_data"):
self.data = self.csv_data.copy()
# self.csv_into_images() # this causes problems now. csv is more likely to be currupt than images.
else:
self.data = {"title": name, "data_type": "spec"}
self.data["data_cols"] = []
for col, attr in [("tth_scan", "tth"), ("alpha", "alpha"), ("t_abs", "tstamp")]:
try:
self.data[col] = np.array(
[getattr(self.images[i], attr) for i in range(len(self))]
)
self.data["data_cols"] += [col]
if verbose:
print(
"got '"
+ attr
+ "' from Pilatus objects"
+ " and saved it as self.data['"
+ col
+ "']"
)
except AttributeError:
if verbose:
print("could not get " + col + ", (" + attr + ") from images.")
# this will conveniently store useful data, some from csv_data
if timecol is None and abstimecol is not None:
# put in the timecol!
self.get_timecol_from_abstimecol()
# ---------------------- get timestamp and timecol -----------------#
if verbose:
print(
"\nGetting tstamp and t according to inputs:\n\t"
+ "timestamp = "
+ str(timestamp)
+ ", tstamp = "
+ str(tstamp)
)
if timestamp in ["filename", "csv", "file"]:
tstamp = self.csv_data["tstamp"]
timestamp = epoch_time_to_timestamp(tstamp, tz=tz)
if verbose:
print("got self.tstamp from self.csv_data")
elif timestamp in ["pdi"]:
tstamp = self.images[0].tstamp
if verbose:
print("got self.tstamp from self.images[0]")
elif timestamp in ["abstimecol"]:
try:
value = self.csv_data[abstimecol][0]
try:
a = re.search(timestamp_matcher, value)
except TypeError:
print(
"ERROR: You're trying to get the timestamp from an absolute"
+ " time column.\n Inputs:\ttimestamp='abstimecol',\tabstimecol='"
+ str(abstimecol)
+ "'\n but self.csv_data[abstimecol] = "
+ str(value)
+ "."
)
raise
timestamp = a.group()
tstamp = timestamp_to_epoch_time(value, tz=tz)
# print('line 163: timestamp = ' + timestamp) # debugging
if timecol is not None:
t = a.csv_data[timecol]
tstamp = tstamp - t[0]
# this is to correct for the fact that tstamp refers to the
timestamp = epoch_time_to_timestamp(tstamp, tz=tz)
# first datapoint
if verbose:
print(
"got self.tstamp from self.csv_data['"
+ abstimecol
+ "'], i.e., abstimecol."
)
except OSError: # a dummy error... I want to actually get the error messages at first
pass
elif "tstamp" in self.csv_data:
tstamp = self.csv_data["tstamp"]
print("got tstamp from self.csv_data")
if "t" not in self.data:
if timecol is not None:
print("getting t from self.csv_data['" + timecol + "'].")
t = self.csv_data[timecol]
elif "t_abs" in self.data:
tstamp = self.data["t_abs"][0]
t = self.data["t_abs"] - tstamp
if verbose:
print("got self.tstamp and self.t from self.data['t_abs']")
else:
try:
t = self.csv_data[self.timecol]
if verbose:
print(
"got self.t from self.csv_data['"
+ self.timecol
+ "'], i.e. timecol."
)
except KeyError:
if self.timecol is not None:
print(
"self.timecol = "
+ str(self.timecol)
+ " is not in csv data. Check yo self."
)
else:
print(
"This is a timescan but there's no time "
+ "variable specified. \nConsider using "
+ "EC_Xray.time_cal() to calibrate and specify one."
)
return
# we can only reach here if 't' has been successfully put into self.data_cols
self.tstamp = tstamp
self.timestamp = timestamp
self.data["tstamp"] = tstamp
self.data["timestamp"] = timestamp
self.data["t"] = t
if "t" not in self.data["data_cols"]:
self.data["data_cols"] += ["t"]
# print('line 170: self.timestamp = ' + str(self.timestamp))
# This code is a bit of a mess, and timestamp is here only for sanity-checking
# purposes. All math will refer to tstamp
# ------- finished ---------- #
if self.verbose:
print("\nScanImages object with name " + self.name + " imported!\n\n")
def __len__(self):
try:
return len(self.images)
except AttributeError:
print(
"len(self) is tricky for scan named '"
+ self.name
+ "' which was loaded without images. Will try to use "
+ "len(self.data['t']) instead"
)
try:
return len(self.data["t"])
except AttributeError:
print("There is no self.data")
except KeyError:
print("self.data has no t.")
return None
def __getitem__(self, indices):
if type(indices) is int:
if type(indices) is int and indices < 0:
indices = len(self) + indices
return self.images[indices]
elif type(indices) in [list, tuple]:
return [self.images[i] for i in indices]
print("indices must be an integer or sequence of integers")
def save(self, filename=None, with_images=False):
savescan = ScanImages(copy=True, scan=self)
if not with_images and hasattr(savescan, "images"):
del savescan.images
if filename is None:
filename = "./" + self.name + ".pkl"
with open(filename, "wb") as f:
pickle.dump(savescan, f)
def append(self, scan):
N = len(self)
for n in range(len(scan)):
self.images[N + n] = scan.images[n]
for col, attr in [("tth_scan", "tth"), ("alpha", "alpha"), ("t_abs", "tstamp")]:
self.data[col] = np.array(
[getattr(self.images[i], attr) for i in range(len(self))]
)
self.data["data_cols"] += [col]
tstamp = self.data["t_abs"][0]
t = self.data["t_abs"] - tstamp
self.data["t"] = t
def csv_into_images(self):
if self.scan_type == "t":
for i in range(len(self)):
# I don't like it, but that's where SPEC saves t.
# data columns 'TTIMER' and 'Seconds' contain nothing.
# If t is recorded, tth and alpha are constant, but...
# The tth and alpha are not saved anywhere. The user must
# input them, or input a macro to read. Done in self.__init__
# print('putting tth=' + str(self.tth) + ' into image!') #debugging
if self.images[i].tth is None:
self.images[i].tth = self.tth
if self.images[i].alpha is None:
self.images[i].alpha = self.alpha
elif self.scan_type == "tth":
self.data["tth_scan"] = self.csv_data["TwoTheta"]
self.data["data_cols"] += ["tth_scan"]
for i in range(len(self)):
# self.data['tth'] will be saved for when calculating the spectrum from the images
self.images[i].tth = self.data["tth_scan"][i]
self.images[i].alpha = self.alpha
elif self.scan_type == "alpha":
for i in range(len(self)):
self.images[i].tth = self.tth
def set_tth(self, tth, update_images=True):
self.tth = tth
if update_images:
for image in self.images.values():
image.tth = tth
def get_timecol_from_abstimecol(self):
abstimecol = self.csv_data[self.abstimecol]
t = []
# print('line 228: self.timestamp = ' + str(self.timestamp))
t0 = self.tstamp
for timecol in abstimecol:
t += [timestamp_to_epoch_time(time, tz=self.tz) - t0]
self.data["t"] = t
if "t" not in self.data["data_cols"]:
self.data["data_cols"] += ["t"]
# -------------- functions for calculating XRD spectra ----------
def get_combined_spectrum(
self,
stepsize=0.05,
override=False,
slits=True,
xslits=None,
yslits=None,
method="sum",
min_pixels=10,
tth=None,
scan_method="sum",
out="spectrum",
weight=None,
recalculate=False,
normalize=None,
):
"""
Calculates conventional tth spectrum (diffractogram) from the pixels
of each Pilatus image. If the image spectra have already been
calculated, they are used unless override is True.
scan_method says whether to add ('sum') or average ('average') the
contributions from each image.
stepsize, method, min_pixels, xslits, yslits, and weight are
all arguments which are passed on to Pilatus.tth_spectrum()
"""
if self.verbose:
print("\n\nfunction 'get_combined_spectrum' at your service!\n")
if hasattr(self, "spectrum") and not recalculate:
return self.spectrum
elif not hasattr(self, "images"):
print("scan '" + self.name + "' has no images! Can't calcualte spectrum")
return
if self.verbose:
t0 = time.time()
print("t = 0")
print(
"calculating tth spectrum for each of "
+ str(len(self))
+ " images, storing in Pilatus objects, and adding them all up."
)
if tth is not None:
self.tth = tthTru
if normalize:
try:
normalizer = self.data[normalize]
if self.verbose:
print(
"normalizing spectra according to self.data['"
+ normalize
+ "']."
)
except KeyError:
normalize = False
raise Warning("normalize must be a key to self.data won't normalize")
bins = {}
contributors = {}
raw_spectra = {}
for i in range(len(self)):
bins_i = self.images[i].tth_spectrum(
out="bins",
override=override,
stepsize=stepsize,
method=method,
min_pixels=min_pixels,
tth=tth,
xslits=xslits,
yslits=yslits,
weight=weight,
verbose=self.vverbose,
)
raw_spectra[i] = self.images[i].spectrum
if normalize:
try:
norm = normalizer[i]
if type(norm) not in [int, float, np.float64]:
raise IndexError
except IndexError:
print(
"encountered a problem in normalizer for image #"
+ str(i)
+ ". Terminating."
)
break
else:
norm = 1
for n, counts in bins_i.items():
if type(n) is not int:
continue
if n in bins:
bins[n] += counts / norm
contributors[n] += [i]
else:
bins[n] = counts / norm
contributors[n] = [i]
if self.verbose:
print("Counts per tth interval calculated locally and globally. ")
tth_vec = []
counts_vec = []
n_min = min(bins.keys())
n_max = max(bins.keys())
for n in range(n_min, n_max + 1):
tth_vec += [(n + 0.5) * stepsize]
if scan_method == "average":
counts_vec += [bins[n] / len(contributors[n])]
else:
counts_vec += [bins[n]]
tth_vec = | np.array(tth_vec) | numpy.array |
import numpy as np
import yaml
import plotly.graph_objects as go
import os
from operator import itemgetter
def cleanup_test_files():
"""
The Rust code panics if the files it writes to already exists. This fn
removes them after they have been used so that the example can be run again.
It also prevents files used only for the tests from accumulating in the repo.
"""
os.remove("./target/debug/examples/reservoirs.yaml")
os.remove("./target/debug/examples/population.yaml")
parameters = {}
with open("./visualizations_python/parameters.yaml") as parameters_file:
parameters = yaml.load(parameters_file, Loader=yaml.CLoader)
with open("./target/debug/examples/reservoirs.yaml") as res_file, open(
"./target/debug/examples/population.yaml"
) as pop_file:
# create iterators containing the data from the yaml docs
reservoirs = yaml.load_all(res_file, Loader=yaml.CLoader)
population = yaml.load_all(pop_file, Loader=yaml.CLoader)
# For the population, extract the sample values; forget the enumeration.
population = [value for i, value in population]
population = np.array(population, dtype=float)
# print("population", population)
# Initialize an array with rows [index, reservoir_mean, population_slice_mean] where:
# index = enumeration of the reservoirs,
# reservoir_mean = mean of the reservoir
# population_slice_mean = mean of the slice of the population from which the reservoir sample was taken
arr = | np.full((parameters["num_res"], 3), 0, dtype=float) | numpy.full |
import os
import torch
import pickle
import gensim
import numpy as np
import pandas as pd
from config import model_config as config
from gensim.scripts.glove2word2vec import glove2word2vec
from sklearn.metrics import confusion_matrix, accuracy_score, f1_score, precision_score, recall_score
import itertools
import matplotlib.pyplot as plt
def generate_word_embeddings(vocab):
if not os.path.exists('{}gensim.glove.6B.{}d.txt'.format(
config['embeddings_dir'], config['embedding_dim'])):
glove2word2vec(glove_input_file='{}glove.6B.{}d.txt'.format(
config['embeddings_dir'], config['embedding_dim']),
word2vec_output_file='{}gensim.glove.6B.{}d.txt'.format(
config['embeddings_dir'], config['embedding_dim']))
embeddings_all = gensim.models.KeyedVectors.load_word2vec_format(
'{}gensim.glove.6B.{}d.txt'.format(config['embeddings_dir'],
config['embedding_dim']))
print('Loaded original embeddings')
# initialize word embeddings matrix
combined_word_embeddings = np.zeros((vocab.size,
config['embedding_dim']))
for index, word in vocab.index2word.items():
try:
if index < 4: # deal with special tokens
combined_word_embeddings[index] = np.random.normal(
size=(config['embedding_dim'], ))
continue
combined_word_embeddings[index] = embeddings_all[word]
except KeyError as e:
print('KeyError triggered for {}'.format(word))
combined_word_embeddings[index] = np.random.normal(
size=(config['embedding_dim'], ))
print('Created combined + filtered embeddings.')
with open('{}saved_{}d_word_embeddings.pkl'.format(
config['embeddings_dir'], config['embedding_dim']), 'wb') as f:
pickle.dump(combined_word_embeddings, f)
combined_word_embeddings = torch.from_numpy(combined_word_embeddings).float()
return combined_word_embeddings
def load_word_embeddings():
with open('{}saved_{}d_word_embeddings.pkl'.format(
config['embeddings_dir'], config['embedding_dim']), 'rb') as f:
combined_word_embeddings = pickle.load(f)
return torch.from_numpy(combined_word_embeddings).float()
def zero_padding(l, fillvalue=config['<PAD>']):
return list(itertools.zip_longest(*l, fillvalue=fillvalue))
def binary_matrix(l, value=config['<PAD>']):
m = []
for i, seq in enumerate(l):
m.append([])
for token in seq:
if token == 0:
m[i].append(0)
else:
m[i].append(1)
return m
# Returns padded input sequence tensor and lengths
def input_var(l, vocab):
indexes_batch = [indexes_from_sentence(vocab, sentence) for sentence in l]
for idx, indexes in enumerate(indexes_batch):
indexes_batch[idx] = indexes_batch[idx] + [config['<EOS>']]
lengths = torch.tensor([len(indexes) for indexes in indexes_batch])
pad_list = zero_padding(indexes_batch)
pad_var = torch.LongTensor(pad_list)
return pad_var, lengths
def indexes_from_sentence(vocab, sentence):
indexes = []
for word in sentence.strip().split():
try:
indexes.append(vocab.word2index[word])
except KeyError as e:
indexes.append(config['<UNK>'])
return indexes[:config['max_sequence_length']]
def load_data(batched=True, test=False, file_dir='../../data/t2e/'):
# Load vocab
with open(config['vocab_path'], 'rb') as f:
vocab = pickle.load(f)
bs = config['batch_size']
ftype = 'test' if test else 'train'
df = pd.read_csv('{}text_{}.csv'.format(file_dir, ftype))
data = (np.array(list(df['transcription'])), | np.array(df['label']) | numpy.array |
# This is modified from Upenn MEAM 620 course:
# https://alliance.seas.upenn.edu/~meam620/wiki/index.php
import numpy as np
import torch
import matplotlib.pyplot as plt
class qd_object:
"""
Struct to hold qd information
"""
def __init__(self):
self.pos = 0
self.vel = 0
self.euler = 0
self.omega = 0
class state_object:
"""
Struct to hold state information
"""
def __init__(self):
self.pos = np.zeros(3)
self.vel = np.zeros(3)
self.acc = np.zeros(3)
self.yaw = 0
self.yawdot = 0
def init_state(s_start):
"""
Initialize 13 x 1 state vector
"""
s = np.zeros(13)
phi0 = 0.0
theta0 = 0.0
psi0 = s_start.yaw
Rot0 = RPYtoRot_ZXY(phi0, theta0, psi0)
Quat0 = RotToQuat(Rot0)
s[0] = s_start.pos[0] #x
s[1] = s_start.pos[1] #y
s[2] = s_start.pos[2] #z
s[3] = s_start.vel[0] #xdot
s[4] = s_start.vel[1] #ydot
s[5] = s_start.vel[2] #zdot
s[6] = Quat0[0] #qw
s[7] = Quat0[1] #qx
s[8] = Quat0[2] #qy
s[9] = Quat0[3] #qz
s[10] = 0 #p
s[11] = 0 #q
s[12] = 0 #r
return s
def QuatToRot(q):
"""
QuatToRot Converts a Quaternion to Rotation matrix written by Daniel Mellinger
"""
# normalize q
q = q / np.sqrt(np.sum(q**2))
qahat = np.zeros([3, 3] )
qahat[0, 1] = -q[3]
qahat[0, 2] = q[2]
qahat[1, 2] = -q[1]
qahat[1, 0] = q[3]
qahat[2, 0] = -q[2]
qahat[2, 1] = q[1]
R = np.identity(3) + 2 * qahat @ qahat + 2 * q[0] * qahat
return R
def RotToQuat(R):
"""
ROTTOQUAT Converts a Rotation matrix into a Quaternion written by <NAME> from the following website,
deals with the case when tr<0 http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
"""
tr = np.sum(np.trace(R))
if (tr > 0):
S = np.sqrt(tr + 1.0) * 2 # S=4*qw
qw = 0.25 * S
qx = (R[2, 1] - R[1, 2]) / S
qy = (R[0, 2] - R[2, 0]) / S
qz = (R[1, 0] - R[0, 1]) / S
elif (R[0, 0] > R[1, 1]) and (R[0, 0] > R[2, 2]):
S = np.sqrt(1.0 + R(1,1) - R(2,2) - R(3,3)) * 2 # S=4*qx
qw = (R[2, 1] - R[1, 2]) / S
qx = 0.25 * S
qy = (R[0, 1] + R[1, 0]) / S
qz = (R[0, 2] + R[2, 0]) / S
elif R[1, 1] > R[2, 2] :
S = np.sqrt(1.0 + R[1, 1] - R[0, 0] - R[2, 2] ) * 2 # S=4*qy
qw = (R[0, 2] - R[2, 0] ) / S
qx = (R[0, 1] + R[1, 0] ) / S
qy = 0.25 * S
qz = (R[1, 2] + R[2, 1] ) / S
else:
S = np.sqrt(1.0 + R[2, 2] - R[0, 0] - R[1, 1] ) * 2 # S=4*qz
qw = (R[1, 0] - R[0, 1] ) / S
qx = (R[0, 2] + R[2, 0] ) / S
qy = (R[1, 2] + R[2, 1] ) / S
qz = 0.25 * S
q = np.array([[qw], [qx], [qy], [qz]])
q = q * np.sign(qw)
return q
def RPYtoRot_ZXY(phi, theta, psi):
"""
RPYtoRot_ZXY Converts roll, pitch, yaw to a body-to-world Rotation matrix.
The rotation matrix in this function is world to body [bRw] you will need to transpose this matrix to get the body
to world [wRb] such that [wP] = [wRb] * [bP], where [bP] is a point in the body frame and [wP] is a point in the
world frame written by <NAME>
"""
R = np.array([[np.cos(psi) * np.cos(theta) - np.sin(phi) * np.sin(psi) * np.sin(theta),
np.cos(theta)*np.sin(psi) + np.cos(psi)*np.sin(phi)*np.sin(theta), -np.cos(phi)*np.sin(theta)],
[-np.cos(phi)*np.sin(psi), np.cos(phi)*np.cos(psi), np.sin(phi)],
[np.cos(psi)*np.sin(theta) + np.cos(theta)*np.sin(phi)*np.sin(psi),
np.sin(psi)*np.sin(theta) - np.cos(psi)*np.cos(theta)*np.sin(phi), np.cos(phi)*np.cos(theta)]])
return R
def RotToRPY_ZXY(R):
"""
RotToRPY_ZXY Extract Roll, Pitch, Yaw from a world-to-body Rotation Matrix
The rotation matrix in this function is world to body [bRw] you will need to transpose the matrix if you have a
body to world [wRb] such that [wP] = [wRb] * [bP], where [bP] is a point in the body frame and [wP] is a point in
the world frame written by <NAME>
bRw = [ cos(psi)*cos(theta) - sin(phi)*sin(psi)*sin(theta),
cos(theta)*sin(psi) + cos(psi)*sin(phi)*sin(theta),
-cos(phi)*sin(theta)]
[-cos(phi)*sin(psi), cos(phi)*cos(psi), sin(phi)]
[ cos(psi)*sin(theta) + cos(theta)*sin(phi)*sin(psi),
sin(psi)*sin(theta) - cos(psi)*cos(theta)*sin(phi),
cos(phi)*cos(theta)]
"""
phi = np.arcsin(R[1, 2])
psi = np.arctan2(-R[1, 0] / np.cos(phi), R[1, 1] / np.cos(phi))
theta = np.arctan2(-R[0, 2] / np.cos(phi), R[2, 2] / np.cos(phi))
return phi, theta, psi
def qdToState(qd):
"""
Converts state vector for simulation to qd struct used in hardware.
x is 1 x 13 vector of state variables [pos vel quat omega]
qd is a struct including the fields pos, vel, euler, and omega
"""
x = np.zeros(13) #initialize dimensions
x[0:3] = qd.pos
x[3:6] = qd.vel
Rot = RPYtoRot_ZXY(qd.euler[0], qd.euler[1], qd.euler[2])
quat = RotToQuat(Rot)
x[6:10] = quat
x[11:13] = qd.omega
return x
def stateToQd(x):
"""
Converts qd struct used in hardware to x vector used in simulation
x is 1 x 13 vector of state variables [pos vel quat omega]
qd is a struct including the fields pos, vel, euler, and omega
"""
qd = qd_object()
# current state
qd.pos = x[0:3]
qd.vel = x[3:6]
qd.Rot = QuatToRot(x[6:10])
#print("Rot:\n", Rot)
print("rotmat in my qd struct:\n", qd.Rot)
[phi, theta, yaw] = RotToRPY_ZXY(qd.Rot)
qd.euler = np.array([phi, theta, yaw])
qd.omega = x[10:13]
return qd
def diamond(t):
"""
Desired diamond trajectory
"""
T = 15
if t < 0:
pos = np.array([0, 0, 0])
vel = np.array([0, 0, 0])
acc = np.array([0, 0, 0])
elif t < T / 4:
pos = np.array([0, np.sqrt(2), np.sqrt(2)]) * t / (T / 4)
vel = np.array([0, np.sqrt(2), np.sqrt(2)]) / (T / 4)
acc = np.array([0, 0, 0])
elif t < T / 2:
pos = np.array([0, np.sqrt(2), np.sqrt(2)]) * (2 - 4 * t / T) + np.array([0, 0, 2 * np.sqrt(2)]) * (
4 * t / T - 1)
vel = np.array([0, np.sqrt(2), np.sqrt(2)]) * (-4 / T) + np.array([0, 0, 2 * np.sqrt(2)]) * (4 / T)
acc = np.array([0, 0, 0])
elif t < 3 * T / 4:
pos = np.array([0, 0, 2 * np.sqrt(2)]) * (3 - 4 * t / T) + np.array([0, -np.sqrt(2), np.sqrt(2)]) * (
4 * t / T - 2)
vel = np.array([0, 0, 2 * np.sqrt(2)]) * (-4 / T) + np.array([0, -np.sqrt(2), np.sqrt(2)]) * (4 / T)
acc = | np.array([0, 0, 0]) | numpy.array |
# Copyright 2020 The PGDL Competition organizers.
#
# 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.
# Scoring program for the PGDL competition
# Main contributor: <NAME>, July 2020-October 2020
# Code for computing the conditional mutual information.
import copy
import numpy as np
def create_combination_name(hparams):
combination = []
for ch, chv in hparams.items():
single_hparam_combination = []
for v in chv:
for w in chv:
single_hparam_combination.append(str(v) + str(w))
if len(combination) == 0:
combination = single_hparam_combination
else:
new_combination = []
for ch in combination:
for sh in single_hparam_combination:
new_combination.append(ch + sh)
combination = new_combination
return combination
def make_key_from_models(model_1, model_2, conditioning_hparam):
key = ""
for ch in conditioning_hparam:
key += str(model_1["hparams"][ch]["current_value"]) + str(
model_2["hparams"][ch]["current_value"]
)
return key
def mi_empty_conditioning_set_table(prediction, model_specs):
a0 = {"+gap": 0, "-gap": 1}
a1 = {"+measure": 0, "-measure": 1}
table = np.zeros((2, 2, 1))
# fill the table
for mid_1 in model_specs:
for mid_2 in model_specs:
try:
k0 = (
"+gap"
if model_specs[mid_1]["gen_gap"] > all_model_repr[mid_2]["gen_gap"]
else "-gap"
)
k1 = "+measure" if prediction[mid_1] > prediction[mid_2] else "-measure"
all_table[a0[k0], a1[k1], 0] += 1
except KeyError as e:
continue
axis_meaning = [a0, a1, None]
return all_table, axis_meaning
def build_mi_table(prediction, model_specs, conditioning_hparams):
if len(conditioning_hparams) == 0:
return mi_empty_conditioning_set_table(prediction, model_specs)
third_axis_len = 1
for hparam in conditioning_hparams:
values = conditioning_hparams[hparam]
third_axis_len *= len(values) ** 2
table = np.zeros((2, 2, third_axis_len))
combinations = create_combination_name(conditioning_hparams)
assert (
len(combinations) == third_axis_len
), "combination length and axis length do not match"
# map to index mapping
a0 = {"+gap": 0, "-gap": 1}
a1 = {"+measure": 0, "-measure": 1}
a2 = {k: i for i, k in enumerate(combinations)}
# fill the table
count = 0
for mid_1 in model_specs:
for mid_2 in model_specs:
try:
gap_positive = (
model_specs[mid_1]["metrics"]["gen_gap"]
> model_specs[mid_2]["metrics"]["gen_gap"]
)
measure_diff_positive = prediction[mid_1] > prediction[mid_2]
k0 = "+gap" if gap_positive else "-gap"
k1 = "+measure" if measure_diff_positive else "-measure"
# assert not gap_positive^measure_diff_positive, 'gap: {:.3f} {:.3f} measure: {:.3f} {:.3f}'.format(model_specs[mid_1]['metrics']['gen_gap'], model_specs[mid_2]['metrics']['gen_gap'], prediction[mid_1], prediction[mid_2])
k2 = make_key_from_models(
model_specs[mid_1], model_specs[mid_2], conditioning_hparams
)
table[a0[k0], a1[k1], a2[k2]] += 1
count += 1
except KeyError as e:
print(e)
continue
axis_meaning = [a0, a1, a2]
return table, axis_meaning
def entropy(p):
total = p.sum()
normalized_p = p / total
log = | np.log2(normalized_p + 1e-12) | numpy.log2 |
# -*- coding: utf-8 -*-
# from shapely.geometry import LineString, Point
from math import tan, pi, atan, sqrt, sin, cos, copysign, atan2, asin, acos
# import utility
from pylab import plt, np, mpl
mpl.rcParams['mathtext.fontset'] = 'stix'
mpl.rcParams['font.family'] = ['STIXGeneral', 'Times New Roman']
CUSTOM = 2
JMAG = 1
FEMM = 0
__all__ = ['VanGogh']
class VanGogh(object):
"""One VanGogh for both FEMM and JMAG"""
__all__ = None
def __init__(self, im, child_index):
self.im = im
self.child_index = child_index
self.plot_object_list = []
def draw_model(self, fraction=1):
# utility functions than wrap shapely functions
if self.child_index == JMAG: # for being consistent with obselete codes
self.plot_sketch_shaft() # Shaft if any
self.draw_rotor_eMach(fraction)
# self.draw_stator_without_non_accurate_shapely(fraction)
elif self.child_index == FEMM: # for easy selecting of objects
# utility.blockPrint()
self.draw_stator_without_non_accurate_shapely(fraction)
self.draw_rotor_without_non_accurate_shapely(fraction)
# self.draw_rotor_eMach(fraction)
# utility.enablePrint()
# self.draw_stator(fraction)
# try:
# self.draw_rotor(fraction)
# except Exception as e:
# raise e
elif self.child_index == CUSTOM:
self.draw_rotor_without_non_accurate_shapely()
self.draw_stator_without_non_accurate_shapely()
def draw_rotor_without_non_accurate_shapely(self, fraction=1):
# Shapely is very poor in accuracy, use your high school geometry knowledge to derive the coordinates!
im = self.im
# origin = Point(0,0)
Stator_Sector_Angle = 2 * pi / im.Qs * 0.5
Rotor_Sector_Angle = 2 * pi / im.Qr * 0.5
''' Part: Rotor '''
if self.child_index == JMAG:
self.init_sketch_rotorCore()
# Draw Points as direction of CCW
# P1
P1 = (-im.Radius_Shaft, 0)
# P2
P2 = (-im.Radius_Shaft * cos(Rotor_Sector_Angle), im.Radius_Shaft * sin(Rotor_Sector_Angle))
# P3
P2_angle = P3_angle = Rotor_Sector_Angle
P3 = (-im.Radius_OuterRotor * cos(Rotor_Sector_Angle), im.Radius_OuterRotor * sin(Rotor_Sector_Angle))
# P4
# print('::', im.Radius_OuterRotor, im.Width_RotorSlotOpen)
# quit()
P4 = (-sqrt(im.Radius_OuterRotor ** 2 - (0.5 * im.Width_RotorSlotOpen) ** 2), 0.5 * im.Width_RotorSlotOpen)
self.draw_arc(P3, P4, P3_angle - self.get_postive_angle(P4), center=(0, 0))
# P5
P5 = (-im.Location_RotorBarCenter - sqrt(im.Radius_of_RotorSlot ** 2 - (0.5 * im.Width_RotorSlotOpen) ** 2),
0.5 * im.Width_RotorSlotOpen)
self.draw_line(P4, P5)
if im.use_drop_shape_rotor_bar == True:
# P6
P6 = (-im.Location_RotorBarCenter, im.Radius_of_RotorSlot)
self.draw_arc(P6, P5, 0.5 * pi - self.get_postive_angle(P5, (-im.Location_RotorBarCenter, 0)),
center=(-im.Location_RotorBarCenter, 0))
# P7
P7 = (-im.Location_RotorBarCenter2, im.Radius_of_RotorSlot2)
self.draw_line(P6, P7)
# P8
P8 = (-im.Location_RotorBarCenter2 + im.Radius_of_RotorSlot2, 0)
self.draw_arc(P8, P7, 0.5 * pi, center=(-im.Location_RotorBarCenter2, 0))
else:
P6 = P7 = None
P8 = (-im.Location_RotorBarCenter + im.Radius_of_RotorSlot, 0)
self.draw_arc(P8, P5, pi - self.get_postive_angle(P5, (-im.Location_RotorBarCenter, 0)),
center=(-im.Location_RotorBarCenter, 0))
if self.child_index == FEMM:
self.some_solver_related_operations_rotor_before_mirror_rotation(im, P6,
P8) # call this before mirror_and_copyrotate
if self.child_index == JMAG:
self.draw_line(P8, P1)
self.draw_arc(P2, P1, P2_angle)
self.draw_line(P2, P3)
self.mirror_and_copyrotate(im.Qr, im.Radius_OuterRotor, fraction,
symmetry_type=2)
self.init_sketch_cage()
if self.child_index == CUSTOM:
# self.draw_line(P8, P1, ls='-.')
self.draw_arc(P2, P1, P2_angle)
# self.draw_line(P2, P3, ls='-.')
# 导条
# P_Bar
P_Bar = (-im.Location_RotorBarCenter - im.Radius_of_RotorSlot, 0)
self.draw_arc(P5, P_Bar, self.get_postive_angle(P5, (-im.Location_RotorBarCenter, 0)),
center=(-im.Location_RotorBarCenter, 0), ls=':')
if self.child_index == JMAG:
self.add_line(P_Bar, P8)
if im.use_drop_shape_rotor_bar == True:
# draw the outline of rotor core for coil to form a region in JMAG
self.draw_arc(P6, P5, 0.5 * pi - self.get_postive_angle(P5, (-im.Location_RotorBarCenter, 0)),
center=(-im.Location_RotorBarCenter, 0))
self.draw_arc(P8, P7, 0.5 * pi, center=(-im.Location_RotorBarCenter2, 0))
else:
raise Exception('Not implemented error')
self.mirror_and_copyrotate(im.Qr, None, fraction,
symmetry_type=2
# merge=False, # bars are not connected to each other, so you don't have to specify merge=False, they will not merge anyway...
# do_you_have_region_in_the_mirror=True # In short, this should be true if merge is false...
)
if self.child_index == FEMM:
self.mirror_and_copyrotate(im.Qr, im.Radius_OuterRotor, fraction)
self.some_solver_related_operations_fraction(im, fraction)
if self.child_index == CUSTOM:
# self.draw_line(P8, P_Bar, ls='-.')
self.mirror_and_copyrotate(im.Qr, im.Radius_OuterRotor, fraction)
# self.Pr_list = [P1,P2,P3,P4,P5,P6,P7,P8,P_Bar]
self.Pr_list = [np.array(P) for P in [P1, P2, P3, P4, P5, P6, P7, P8] if P is not None]
for P in self.Pr_list:
self.ax.scatter(*P, c='k', marker='None')
# rotor objects
self.rotor_object_list = self.plot_object_list
self.plot_object_list = []
for ind, P in enumerate([P1, P2, P3, P4, P5, P6, P7, P8]):
print('rP' + str(ind + 1), P)
def draw_stator_without_non_accurate_shapely(self, fraction=1):
im = self.im
# origin = Point(0,0)
origin = [0, 0]
Stator_Sector_Angle = 2 * pi / im.Qs * 0.5
Rotor_Sector_Angle = 2 * pi / im.Qr * 0.5
''' Part: Stator '''
if self.child_index == JMAG:
self.init_sketch_statorCore()
# Draw Points as direction of CCW
# P1
P1 = (-im.Radius_OuterRotor - im.Length_AirGap, 0)
# P2
Radius_InnerStator = im.Radius_OuterRotor + im.Length_AirGap
P2_angle = im.Angle_StatorSlotOpen * 0.5 / 180 * pi
P2_rot = (-Radius_InnerStator * cos(P2_angle), -Radius_InnerStator * sin(P2_angle))
P2 = self.park_transform(P2_rot, Stator_Sector_Angle)
self.draw_arc(P2, P1, self.get_postive_angle(P2))
# P3
P3_rot = (P2_rot[0] - im.Width_StatorTeethHeadThickness, P2_rot[1])
P3 = self.park_transform(P3_rot, Stator_Sector_Angle)
self.draw_line(P2, P3)
# P4 (P4 is better to compute using intersection, error from shapely will not really cause a problem while modeling)
c = (
origin, im.Radius_OuterRotor + im.Length_AirGap + im.Width_StatorTeethHeadThickness + im.Width_StatorTeethNeck)
l = [(0, 0.5 * im.Width_StatorTeethBody), (-im.Radius_OuterStatorYoke, 0.5 * im.Width_StatorTeethBody)]
intersections = self.get_node_at_intersection(c, l)
if intersections[0][0] < 0:
P4 = intersections[0]
else:
P4 = intersections[1]
self.draw_line(P3, P4)
# P5
P5 = (
-sqrt(im.Radius_InnerStatorYoke ** 2 - (0.5 * im.Width_StatorTeethBody) ** 2), 0.5 * im.Width_StatorTeethBody)
self.draw_line(P4, P5)
# P6
# k = -tan(Stator_Sector_Angle)
# l_sector = LineString([(0,0), (-im.Radius_OuterStatorYoke, -im.Radius_OuterStatorYoke*k)])
# P6 = self.get_node_at_intersection(c,l_sector)
P6 = (
-im.Radius_InnerStatorYoke * cos(Stator_Sector_Angle), im.Radius_InnerStatorYoke * sin(Stator_Sector_Angle))
self.draw_arc(P6, P5, Stator_Sector_Angle - self.get_postive_angle(P5))
# P7
# c = self.create_circle(origin, im.Radius_OuterStatorYoke)
# P7 = self.get_node_at_intersection(c,l_sector)
P7 = [-im.Radius_OuterStatorYoke * cos(Stator_Sector_Angle),
im.Radius_OuterStatorYoke * sin(Stator_Sector_Angle)]
# P8
P8 = (-im.Radius_OuterStatorYoke, 0)
if self.child_index == JMAG:
self.draw_line(P6, P7)
self.draw_arc(P7, P8, Stator_Sector_Angle)
self.draw_line(P8, P1)
self.mirror_and_copyrotate(im.Qs, None, fraction,
symmetry_type=2, # 2: x-axis
)
self.init_sketch_coil()
if self.child_index == CUSTOM:
# self.draw_line(P6, P7, ls='-.')
self.draw_arc(P7, P8, Stator_Sector_Angle)
# self.draw_line(P8, P1, ls='-.')
# P_Coil
# l = LineString([(P3[0], P3[1]), (P3[0], im.Radius_OuterStatorYoke)])
# P_Coil = self.get_node_at_intersection(l_sector, l)
P_Coil = (P3[0], abs(P3[0]) * tan(Stator_Sector_Angle))
if self.child_index == JMAG: # F*ck you, Shapely for putting me through this!
# temp = 0.7071067811865476*(P_Coil[1] - P4[1])
# P4 = [ P4[0], P4[1] + temp]
# P5 = [P5[0] + 0.7071067811865476*(P4[0] - P5[0]), P5[1] + temp]
# P6 = []
# we use sin cos to find P6 and P7, now this suffices.
P6[1] -= 0.01
# Conclusion: do not use the intersection between l_sector and a circle!
# Conclusion: do not use the intersection between l_sector and a circle!
# Conclusion: do not use the intersection between l_sector and a circle!
# 总之，如果overlap了，merge一下是没事的，麻烦就在Coil它不能merge，所以上层绕组和下层绕组之间就产生了很多Edge Parts。
if self.child_index == CUSTOM:
# self.Ps_list = [P1,P2,P3,P4,P5,P6,P7,P8,P_Coil]
self.Ps_list = [np.array(P) for P in [P1, P2, P3, P4, P5, P6, P7, P8]]
for P in self.Ps_list:
self.ax.scatter(*P, c='k', marker='None')
# stator objects
self.stator_object_list = self.plot_object_list
self.plot_object_list = []
for ind, P in enumerate([P1, P2, P3, P4, P5, P6, P7, P8]):
print('sP' + str(ind + 1), P)
else:
self.draw_line(P4, P_Coil)
self.draw_line(P6, P_Coil)
if self.child_index == JMAG:
# draw the outline of stator core for coil to form a region in JMAG
self.draw_line(P4, P5)
self.draw_arc(P6, P5, Stator_Sector_Angle - self.get_postive_angle(P5))
self.mirror_and_copyrotate(im.Qs, None, fraction,
edge4ref=self.artist_list[1], # 'Line.2'
# symmetry_type=2,
merge=False, # two layers of windings
do_you_have_region_in_the_mirror=True
# In short, this should be true if merge is false...
)
# it is super wierd that use edge Line.2 as symmetry axis will lead to redundant parts imported into JMAG Designers (Extra Coil and Stator Core Parts)
# symmetry_type=2 will not solve this problem either
# This is actually caused by the overlap of different regions, because the precision of shapely is shit!
# FEMM does not model coil and stator core separately
if self.child_index == FEMM:
self.mirror_and_copyrotate(im.Qs, im.Radius_OuterStatorYoke, fraction)
def draw_rotor_eMach(self, fraction):
def utilityTangentPointsOfTwoCircles(C1, C2, r, R):
x1 = C1[0];
y1 = C1[1]
x2 = C2[0];
y2 = C2[1]
gamma = -atan((y2 - y1) / (x2 - x1))
distance = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
beta = asin((R - r) / distance)
alpha = gamma - beta
x3 = x1 + r * cos(0.5 * pi - alpha)
y3 = y1 + r * sin(0.5 * pi - alpha)
x4 = x2 + R * cos(0.5 * pi - alpha)
y4 = y2 + R * sin(0.5 * pi - alpha)
# (x3,y3) and (x4,y4) are outer tangent points on one side.
coord3 = [x3, y3]
coord4 = [x4, y4]
return coord3, coord4
d_rs = self.im.Location_RotorBarCenter - self.im.Location_RotorBarCenter2
d_ro = self.im.Length_HeadNeckRotorSlot
w_ro = self.im.Width_RotorSlotOpen
w_rs1 = self.im.Radius_of_RotorSlot
w_rs2 = self.im.Radius_of_RotorSlot2
R_or = self.im.Radius_OuterRotor
R_ir = self.im.Radius_Shaft
Qr = self.im.Qr
# origin = [0,0]
angleRotorSector = 2 * pi / Qr * 0.5
''' Part: Rotor '''
if self.child_index == JMAG:
self.init_sketch_rotorCore()
# Draw Points as direction of CCW
P1 = (-R_ir, 0)
P2 = [-R_ir * cos(angleRotorSector), R_ir * sin(angleRotorSector)]
P3 = [-R_or * cos(angleRotorSector), R_or * sin(angleRotorSector)]
x, y = self.linecirc(0, 0.5 * w_ro, 0, 0, R_or)
if np.isnan(y).all(): # all element are True?
raise Exception('Error: provided line and circle have no intersection.')
elif x[0] < 0:
P4 = [x[0], y[0]]
else:
P4 = [x[1], y[1]]
CenterP5P6 = [-(R_or - d_ro - w_rs1), 0]
[x, y] = self.linecirc(0, 0.5 * w_ro, CenterP5P6[0], CenterP5P6[1], w_rs1)
if np.isnan(y).all():
raise Exception('Error: provided line and circle have no intersection.')
elif x[0] < CenterP5P6[0]:
P5 = [x[0], y[0]]
else:
P5 = [x[1], y[1]]
if self.im.use_drop_shape_rotor_bar == True:
CenterP7P8 = [-(R_or - d_ro - w_rs1 - d_rs), 0]
[P6, P7] = utilityTangentPointsOfTwoCircles(CenterP5P6, CenterP7P8, w_rs1, w_rs2)
if P6[1] < 0:
P6[1] = -1 * P6[1]
P7[1] = -1 * P7[1]
if P6[0] > P7[0]:
P6, P7 = P7, P6
P8 = [-(R_or - d_ro - w_rs1 - d_rs - w_rs2), 0]
else:
P6 = P7 = None
P8 = [-(R_or - d_ro - 2 * w_rs1), 0]
self.listKeyPoints = [P1, P2, P3, P4, P5, P6, P7, P8];
drawer = self
arc21 = drawer.drawArc([0, 0], P2, P1)
line23 = drawer.drawLine(P2, P3)
arc34 = drawer.drawArc([0, 0], P3, P4)
line45 = drawer.drawLine(P4, P5)
line81 = drawer.drawLine(P8, P1)
if self.im.use_drop_shape_rotor_bar == True:
arc65 = drawer.drawArc(CenterP5P6, P6, P5)
line67 = drawer.drawLine(P6, P7)
arc87 = drawer.drawArc(CenterP7P8, P8, P7)
segments = [arc21, line23, arc34, line45, arc65, line67, arc87, line81]
else:
arc85 = drawer.drawArc(CenterP5P6, P8, P5) # CenterP5P6 is the same as CenterP5P8
segments = [arc21, line23, arc34, line45, arc85, line81]
csToken = segments
im = self.im
if self.child_index == FEMM:
self.some_solver_related_operations_rotor_before_mirror_rotation(im, P6,
P8) # call this before mirror_and_copyrotate to asign segment size to the arc to reduce element number
if self.child_index == JMAG:
# JMAG needs to explictly draw the rotor slot.
drawer.drawLine(P8, P1)
drawer.drawArc([0, 0], P2, P1)
drawer.drawLine(P2, P3)
self.mirror_and_copyrotate(im.Qr, im.Radius_OuterRotor, fraction,
symmetry_type=2)
self.init_sketch_cage()
if self.child_index == CUSTOM:
# self.draw_line(P8, P1, ls='-.')
self.draw_arc(P2, P1, P2_angle)
# self.draw_line(P2, P3, ls='-.')
# P_Bar
P_Bar = (-im.Location_RotorBarCenter - im.Radius_of_RotorSlot, 0)
drawer.drawArc((-im.Location_RotorBarCenter, 0), P5, P_Bar, ls=':')
if self.child_index == JMAG:
drawer.drawLine(P_Bar, P8)
drawer.drawLine(P6, P7)
# draw the outline of stator core for coil to form a region in JMAG
drawer.drawArc((-im.Location_RotorBarCenter, 0), P6, P5)
drawer.drawArc((-im.Location_RotorBarCenter2, 0), P8, P7)
self.mirror_and_copyrotate(im.Qr, None, fraction,
symmetry_type=2
# merge=False, # bars are not connected to each other, so you don't have to specify merge=False, they will not merge anyway...
# do_you_have_region_in_the_mirror=True # In short, this should be true if merge is false...
)
if self.child_index == FEMM:
self.mirror_and_copyrotate(im.Qr, im.Radius_OuterRotor, fraction)
self.some_solver_related_operations_fraction(im, fraction)
if self.child_index == CUSTOM:
# self.draw_line(P8, P_Bar, ls='-.')
self.mirror_and_copyrotate(im.Qr, im.Radius_OuterRotor, fraction)
# self.Pr_list = [P1,P2,P3,P4,P5,P6,P7,P8,P_Bar]
self.Pr_list = [np.array(P) for P in [P1, P2, P3, P4, P5, P6, P7, P8]]
for P in self.Pr_list:
self.ax.scatter(*P, c='k', marker='None')
# rotor objects
self.rotor_object_list = self.plot_object_list
self.plot_object_list = []
for ind, P in enumerate([P1, P2, P3, P4, P5, P6, P7, P8]):
print('rP' + str(ind + 1), P)
def drawLine(self, PA, PB):
self.draw_line(PA, PB)
def drawArc(self, CenterPAPB, PA, PB, **kwarg):
if self.child_index == JMAG: # plot arc using center and two points
self.draw_arc(CenterPAPB, PA, PB)
elif self.child_index == FEMM or self.child_index == CUSTOM: # plot arc using arc angle and two points
angle = abs(self.get_postive_angle(PA) - self.get_postive_angle(PB))
self.draw_arc(PA, PB, angle, **kwarg) # angle in rad
@staticmethod
def park_transform(P_rot, angle):
return (cos(angle) * P_rot[0] + sin(angle) * P_rot[1],
-sin(angle) * P_rot[0] + cos(angle) * P_rot[1])
# this method is found to be very low in accuracy, don't use it, just specify the center if know!
@staticmethod
def find_center_of_a_circle_using_2_points_and_arc_angle(p1, p2, angle):
return find_center_and_radius_of_a_circle_using_2_points_and_arc_angle(p1, p2, angle)[0]
@staticmethod
def find_center_and_radius_of_a_circle_using_2_points_and_arc_angle(p1, p2, angle):
distance = sqrt((p2[0] - p1[0]) ** 2 + (p2[1] - p1[1]) ** 2)
radius = distance * 0.5 / sin(angle * 0.5)
c1 = Point(p1[0], p1[1]).buffer(radius).boundary
c2 = Point(p2[0], p2[1]).buffer(radius).boundary
i = c1.intersection(c2)
# print len(i.geoms)
# print i.geoms[0].coords[0]
# print i.geoms[1].coords[0]
# if len(i.geoms) > 2:
# print 'There are more than 2 intersections!'
# print p1, p2, angle
# print c1.coords[0], c1.coords[1], c1.coords[2]
# print c2.coords[0], c2.coords[1], c2.coords[2]
# for el in i.geoms:
# print '\t', el.coords[0]
# print 'Crazy Shapely.'
# # (0.013059471222689467, 0.46233200000038793)
# # (0.013059471222689467, 0.462332)
# # (-93.94908807906135, 4.615896979306289)
# # raise Exception('Too many intersections.')
if i.geoms is None:
raise Exception('There is no intersection.')
for center in [el.coords[0] for el in i.geoms]: # shapely does not return intersections in a known order
# print center
determinant = (center[0] - p1[0]) * (p2[1] - p1[1]) - (center[1] - p1[1]) * (p2[0] - p1[0])
if copysign(1, determinant) < 0: # CCW from p1 to p2
return center, radius
@staticmethod
def create_circle(p, radius):
return p.buffer(radius).boundary
@staticmethod
def get_postive_angle(p, center=(0, 0)):
# using atan loses info about the quadrant, so it is "positive"
return atan(abs((p[1] - center[1]) / (p[0] - center[0])))
@staticmethod
def get_node_at_intersection(c, l):
# this works for c and l having one or two intersections
if c[0][0] != 0 or c[0][1] != 0:
raise Exception('Not implemented for non-origin centered circle.')
r = c[1]
c = None
x1, y1 = l[0][0], l[0][1]
x2, y2 = l[1][0], l[1][1]
if x1 == x2:
raise Exception('Not implemented.')
a = -(y2 - y1) / (x2 - x1)
b = 1
c = y1 - (y2 - y1) / (x2 - x1) * x1
Delta = sqrt(r ** 2 * (a ** 2 + b ** 2) - c ** 2)
if Delta < 0:
raise Exception('No intersection for given line and circle')
x_solutions = (a * c + b * Delta) / (a ** 2 + b ** 2), (a * c - b * Delta) / (a ** 2 + b ** 2)
y_solutions = (b * c - a * Delta) / (a ** 2 + b ** 2), (b * c + a * Delta) / (a ** 2 + b ** 2)
return (x_solutions[0], y_solutions[0]), (x_solutions[1], y_solutions[1])
@staticmethod
def linecirc(slope, intercpt, centerx, centery, r):
# Input data are in alpha-beta frame:
# -slope*alpha + beta = intercpt
# (alpha - c_x)**2 + (beta - c_y)**2 = r**2
# Translation of coordinates:
# let x = alpha - c_x
# let y = beta - c_y
# We have:
# a*x + b*y = c
# x**2 + y**2 = r**2
# The solution in x-y coordinates should be transormed back:
# alpha = x + c_x
# beta = y + c_y
a = -slope
b = 1
c = intercpt
Delta = sqrt(r ** 2 * (a ** 2 + b ** 2) - c ** 2)
if Delta < 0:
raise Exception('No intersection for given line and circle')
x_solutions = (a * c + b * Delta) / (a ** 2 + b ** 2), (a * c - b * Delta) / (a ** 2 + b ** 2)
y_solutions = (b * c - a * Delta) / (a ** 2 + b ** 2), (b * c + a * Delta) / (a ** 2 + b ** 2)
return (x_solutions[0] + centerx, x_solutions[1] + centerx), (
y_solutions[0] + centery, y_solutions[1] + centery)
from .utility import csv_row_reader
class VanGogh_pyPlotter(VanGogh):
"""VanGogh_pyPlotter is child class of VanGogh for plotting IM geometry in matplotlib."""
def __init__(self, im, child_index=2):
super(VanGogh_pyPlotter, self).__init__(im, child_index)
self.add_line = self.draw_line
self.add_arc = self.draw_arc
self.fig = plt.figure(figsize=(8, 8), facecolor='w', edgecolor='k')
self.ax = self.fig.add_subplot(111, aspect='equal')
# self.ax = self.fig.gca()
# self.ax.set_xlim([-74,-40])
self.ax.set_ylim([-10, 25])
# plt.gcf().gca().invert_yaxis()
# Embeded TikZ function
self.tikz = VanGogh_TikZPlotter()
@staticmethod
def mirror_and_copyrotate(Q, Radius, fraction):
# Mirror
# femm.mi_selectcircle(0,0,Radius+EPS,SELECT_ALL) # this EPS is sometime necessary to selece the arc at Radius.
# femm.mi_mirror2(0,0,-Radius,0, SELECT_ALL)
# Rotate
# femm.mi_selectcircle(0,0,Radius+EPS,SELECT_ALL)
# femm.mi_copyrotate2(0, 0, 360./Q, int(Q)/fraction, SELECT_ALL)
return
def draw_arc(self, p1, p2, angle, center=(0, 0), **kwarg):
# Embeded TikZ function
self.tikz.draw_arc(p1, p2, center, relangle=-0.5 * angle)
# center, radius = self.find_center_and_radius_of_a_circle_using_2_points_and_arc_angle(p1, p2, angle) # ordered p1 and p2 are
# print sqrt((p1[0]-center[0])**2 + (p1[1]-center[0])**2)
# print sqrt((p2[0]-center[0])**2 + (p2[1]-center[0])**2)
distance = sqrt((p2[0] - p1[0]) ** 2 + (p2[1] - p1[1]) ** 2)
radius = distance * 0.5 / sin(angle * 0.5)
obj = self.pyplot_arc(radius, angle_span=angle, rotation=atan2(p1[1] - center[1], p1[0] - center[0]),
center=center, **kwarg)
self.plot_object_list.append(obj[0])
return obj
def pyplot_arc(self, radius, angle_span=3.14, center=(0, 0), rotation=0, maxseg=0.1, ax=None, **kwarg):
# Plot an arc starting from x-axis to axis aligned to angle_span. Use rotation to change the beginning axis.
# make sure ax is not empty
if ax is None:
ax = self.ax
# ax = plt.gcf().gca()
# turn Polar into Cartesian
def xy(radius, phi, center):
return radius * np.cos(phi) + center[0], radius * np.sin(phi) + center[1]
# get list of points
# phis = np.arange(rotation, rotation+angle_span, 2*radius*np.pi / (360./maxseg))
phis = np.linspace(rotation, rotation + angle_span, int(360. / maxseg))
return ax.plot(*xy(radius, phis, center), c='k', **kwarg)
def draw_line(self, p1, p2, ax=None, **kwarg):
# Embeded TikZ function
self.tikz.draw_line(p1, p2)
# make sure ax is not empty
if ax is None:
ax = self.ax
obj = ax.plot([p1[0], p2[0]], [p1[1], p2[1]], c='k', **kwarg)
self.plot_object_list.append(obj[0])
return obj
import pyx
# from pyx import *
# text.set(mode="latex")
# text.preamble(r"\usepackage{ulem}") # underlining text...
# text.preamble(r"\usepackage{anyfontsize}") # one way of scaling fonts (except math fonts)....
# import PyX_Utility
class VanGogh_TikZPlotter():
"""VanGogh_TikzPlotter is child class of VanGogh for plotting IM geometry in TikZ.
The idea here is to incorporate this class with VanGogh_pyPlotter,
such that what you see in Matplotlib is what you get in TikZ."""
def __init__(self):
self.add_line = self.draw_line
self.add_arc = self.draw_arc
self.file = open('VanGogh_TikZ.tex', 'w')
self.c = pyx.canvas.canvas()
self.track_path = []
self.gray_color_auto = 1.0
@staticmethod
def mirror_and_copyrotate(Q, Radius, fraction):
return
def getSketch(self, sketchName, color=None):
print('%s @ getSketch: I am dummy function to be consistent with JMAG codes.' % (sketchName))
def prepareSection(self, list_regions, bMirrorMerge=True, bRotateMerge=True, color=None, **kwarg):
# print('@ prepareSection: I am dummy function to be consistent with JMAG codes.')
# print('_________________________________________________')
for list_segments in list_regions:
for segment in list_segments:
路径列表 = []
# bool_first_segment = True
# if False: # fill not as expected
for segment in list_segments:
# print(segment)
路径列表.append(self.pyx_draw_path(segment, sign=1)) # sign必须调整的，否则画出来的arc的方向可能是错的
# print('路径列表长度：', len(路径列表))
# print(路径列表)
# Note that joining two paths might insert a line connecting the first and the second path. For example, we could skip the second line when constructing rect2 in our example above without any change in the result. --https://pyx-project.org/examples/path/addjoin.html
# 如果自动添加的线在染色区域内部，那么fill了以后，那根线也看不见了。
# 此外，如果自动添加的线在染色区域外部，那么你只能额外画一个图形把多涂色的地方给覆盖掉了。
# 路径 = self.draw_line([0,0], [0,0], untrack=True)
# 路径 = pyx.path.path(pyx.path.moveto(0,0))
# 路径 = pyx.path.path(路径列表[0])
# 路径 = self.draw_arc([0,-0.1], [0,0.1], [0,0], relangle=2, untrack=True)
# 路径 = 路径 + 路径列表[0]
路径 = 路径列表[0]
for el in 路径列表[1:]:
路径 = 路径 << el # << means join; + means add
路径.append(
pyx.path.closepath()) # see https://stackoverflow.com/questions/50570100/filling-a-closed-curve-in-pyx-python-failing
# print(路径.normpath().normsubpaths)
if color is None:
self.gray_color_auto -= 0.075
color_setting = pyx.color.gray(self.gray_color_auto)
else:
color_setting = pyx.color.rgb(*color)
self.c.fill(路径, [color_setting])
# self.c.stroke(路径, [pyx.style.linewidth.THICK])
if self.iRotateCopy == 0 and self.bMirror == True:
self.c.fill(路径, [color_setting, pyx.trafo.mirror(0)])
# self.c.stroke(路径, [pyx.style.linewidth.THICK, pyx.trafo.mirror(0)])
# self.c.fill(路径, [color_setting, pyx.trafo.rotate(360/self.iRotateCopy)])
# self.c.fill(路径, [color_setting, pyx.trafo.mirror(0), pyx.trafo.rotate(360/self.iRotateCopy)])
# self.c.fill(路径, [color_setting, pyx.trafo.rotate(360/self.iRotateCopy*2)])
# self.c.fill(路径, [color_setting, pyx.trafo.mirror(0), pyx.trafo.rotate(360/self.iRotateCopy*2)])
if self.iRotateCopy != 0:
for i in range(self.iRotateCopy):
self.c.fill(路径, [color_setting, pyx.trafo.rotate(i * 360 / self.iRotateCopy)])
# self.c.stroke(路径, [pyx.style.linewidth.THICK, pyx.trafo.rotate(i*360/self.iRotateCopy)])
if self.bMirror == True:
self.c.fill(路径,
[color_setting, pyx.trafo.mirror(0), pyx.trafo.rotate(i * 360 / self.iRotateCopy)])
# self.c.stroke(路径, [pyx.style.linewidth.THICK, pyx.trafo.mirror(0), pyx.trafo.rotate(i*360/self.iRotateCopy)])
def drawLine(self, p1, p2):
self.draw_line(p1, p2)
# return [str(p1)+','+str(p2)] # easy to read for human
return [(p1[0], p1[1], p2[0], p2[1])] # This is segment
# Consistent with : self.track_path.append([p1[0], p1[1], p2[0], p2[1]])
def draw_line(self, p1, p2, ax=None, bool_stroke=False, **kwarg):
msg = '\\draw[black] (%12.8f,%12.8f) -- (%12.8f,%12.8f);\n' % (p1[0], p2[0], p1[1], p2[1])
# print(msg)
self.file.write(msg)
# PyX
路径 = pyx.path.line(p1[0], p1[1], p2[0], p2[1])
if bool_stroke:
self.c.stroke(路径, [pyx.color.rgb.black, pyx.style.linewidth.THICK])
self.c.fill(pyx.path.circle(p1[0], p1[1],
1 * 0.075)) # use this if THICK is used. 这里前面乘的7是和pyx.unit.set(wscale=7)一致的。按照官方manual，如果用的join，就不用担心连接处断裂，但是咱们默认都是用的add。
self.c.fill(pyx.path.circle(p2[0], p2[1],
1 * 0.075)) # use this if THICK is used. 这里前面乘的7是和pyx.unit.set(wscale=7)一致的。按照官方manual，如果用的join，就不用担心连接处断裂，但是咱们默认都是用的add。
# p = pyx.path.path(pyx.path.moveto(p1[0], p1[1]), pyx.path.lineto(p2[0], p2[1]), pyx.path.closepath())
# self.c.stroke(p, [pyx.color.rgb.black, pyx.style.linewidth.Thick])
if 'untrack' not in kwarg:
self.track_path.append([p1[0], p1[1], p2[0], p2[1]])
# # extra vertices
# self.c.fill(pyx.path.circle(p1[0], p1[1], 0.25))
# self.c.fill(pyx.path.circle(p2[0], p2[1], 0.25))
return 路径
def drawArc(self, centerxy, startxy, endxy):
# wrong:
# angle_between_points = self.get_postive_angle(endxy, center=centerxy) - self.get_postive_angle(startxy, center=centerxy) # assume both points are on the circle of the arc
# correct:
angle_between_points = atan2(endxy[1], endxy[0]) - atan2(startxy[1], startxy[0])
relangle = -0.5 * angle_between_points # simple math: https://pyx-project.org/manual/connector.html?highlight=relangle
self.draw_arc(startxy, endxy, centerxy=centerxy, relangle=relangle)
# return [str(startxy)+','+str(endxy)] # easy to read for human
return [(startxy[0], startxy[1], endxy[0], endxy[1], centerxy[0], centerxy[1], relangle)] # This is segment
# Consistent with: self.track_path.append([startxy[0], startxy[1], endxy[0], endxy[1], centerxy[0], centerxy[1], kwarg['relangle']])
def draw_arc(self, startxy, endxy, centerxy=(0, 0), bool_stroke=False, **kwarg): # ccw=-1,
# Example: Output to .tex file
if False:
# %DRAWARC Draw an arc in the current TikZ graphic.
# % drawarc(mn, [center_x,_y], [start_x, _y], [end_x, _y])
# % draws an arc
# % Extract and rename variables for processing
h = centerxy[0]
k = centerxy[1]
x1 = startxy[0]
y1 = startxy[1]
x2 = endxy[0]
y2 = endxy[1]
# % Need to calculate: x, y, start, stop, radius...
x = x1
y = y1
radius = sqrt((x1 - h) ** 2 + (y1 - k) ** 2)
# % These are both "correct" ways of determining start variable,
# % but only one works depending on orientation of arc. Hacks
# % below help solve this issue.
start = acos((x1 - h) / radius)
start2 = asin((y1 - k) / radius)
temp = (x2 - h) / radius
if temp >= 1:
# print 'temp=', temp
temp = 1
elif temp <= -1:
# print 'temp=', temp
temp = -1
stop = acos(temp)
# % ----------
# % HACKS START
# % ----------
# % The code in this "hack" section is special cases for drawing
# % an arc... This involves mostly cases where x1==x2 or
# % y1==y2. I have not proved these are the correct solutions,
# % but I have tried many arcs using various stator geometries
# % and it seems to work for all cases... �_(?)_/�
if (start > stop):
start = -start
stop = -stop
# % Trying to check for start == stop.
# % BUT, issues with rounding and floating numbers....
# % Using this delta comparison fixes one silly case where
# % rounding causes issues for direct comparison for equality...
# %
# % Silly!
# %
if (abs(start - stop) < 0.0000001):
if (y1 - k < 0):
start = -start
elif (x1 - h < 0):
stop = start + (2 * start2)
# % --------
# % HACKS END
# % --------
def rad2deg(rad):
return rad / pi * 180.
msg = '\\draw[black] (%12.8f,%12.8f) arc (%12.8f:%12.8f:%12.8f);\n' % (
x, y, rad2deg(start), rad2deg(stop), radius)
# print(msg)
self.file.write(msg)
# Below is PyX | Above is TikZ (FYI, TikZ is written by Eric and is not working as expected, so use my PyX codes instead)
# Below is PyX | Above is TikZ (FYI, TikZ is written by Eric and is not working as expected, so use my PyX codes instead)
# Below is PyX | Above is TikZ (FYI, TikZ is written by Eric and is not working as expected, so use my PyX codes instead)
if 'untrack' not in kwarg:
self.track_path.append(
[startxy[0], startxy[1], endxy[0], endxy[1], centerxy[0], centerxy[1], kwarg['relangle']])
if True:
# PyX: Option 1: use pyx.connector
textattrs = [pyx.text.halign.center, pyx.text.vshift.middlezero]
X = pyx.text.text(startxy[0], startxy[1], r"",
textattrs) # must have textattrs or else you will have normsubpath cannot close error: AssertionError: normsubpathitems do not match
Y = pyx.text.text(endxy[0], endxy[1], r"", textattrs)
路径 = pyx.connector.arc(X, Y, boxdists=[0.0, 0.0], relangle=kwarg['relangle'] / pi * 180)
if bool_stroke:
self.c.stroke(路径, [pyx.color.rgb.black,
pyx.style.linewidth.THICK]) # https://pyx-project.org/manual/connector.html?highlight=relangle
# print '[%g,%g,%g,%g,%g],'%(startxy[0], startxy[1], endxy[0], endxy[1], 0.5*kwarg['relangle'])
else:
# PyX: Option 2: use pyx.arc.
radius = np.sqrt((startxy[0] - centerxy[0]) ** 2 + (startxy[1] - centerxy[1]) ** 2)
angle_start = np.arctan2((startxy[1] - centerxy[1]), (startxy[0] - centerxy[0])) / np.pi * 180
angle_end = np.arctan2((endxy[1] - centerxy[1]), (endxy[0] - centerxy[0])) / np.pi * 180
if ccw == 1:
路径 = pyx.path.path(pyx.path.arc(centerxy[0], centerxy[1], radius, angle_start, angle_end - angle_start))
else:
路径 = pyx.path.path(
pyx.path.arcn(centerxy[0], centerxy[1], radius, angle_start, angle_end - angle_start))
if bool_stroke:
pass
# See PyX_Utility.py
# Or
# See pyx_fill_example.py
# from pylab import np
# upArc = path.path(path.arc(0,0,1,240,300))
# right = path.line(0,0,1*np.cos(240/180*np.pi),1*np.sin(240/180*np.pi))
# left = path.line(1*np.cos(300/180*np.pi),1*np.sin(300/180*np.pi),0,0)
# p = right<<upArc<<left
# c.fill(p,[color.gray(0.9)])
# c.stroke(p, [style.linewidth.thin]) # comment this for no outline/
# c.insert(cL,[trafo.translate(-2,0)])
# c.insert(cR,[trafo.translate( 2,0)])
# c.writePDFfile("minfail")
# p.append(path.closepath()) # see https://stackoverflow.com/questions/50570100/filling-a-closed-curve-in-pyx-python-failing
# # extra vertices
# self.c.fill(pyx.path.circle(startxy[0], startxy[1], 0.25))
# self.c.fill(pyx.path.circle(endxy[0], endxy[1], 0.25))
return 路径
def pyx_draw_path(tool_tikz, path, sign=1, bool_exclude_path=False, bool_stroke=False):
# 这个函数完全可以写成 VanGogh.VanGogh_TikZPlotter() 的成员函数的。。。
if bool_exclude_path == False:
if len(path) == 4: # line
p = tool_tikz.draw_line(path[:2], path[2:4], untrack=True, bool_stroke=bool_stroke)
else: # == 6 for arc
p = tool_tikz.draw_arc(path[:2], path[2:4], path[4:6], relangle=sign * path[6], untrack=True, ccw=sign,
bool_stroke=bool_stroke)
return p
# wiki: https://en.wikipedia.org/wiki/Tangent_lines_to_circles
def get_tangent_points_of_two_circles(center1, radius1, center2, radius2):
x1, y1 = center1[0], center1[1]
r = radius1
x2, y2 = center2[0], center2[1]
R = radius2
gamma = - atan((y2 - y1) / (x2 - x1))
beta = asin((R - r) / sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2))
alpha = gamma - beta
x3, y3 = x1 + r * cos(0.5 * pi - alpha), y1 + r * sin(0.5 * pi - alpha),
x4, y4 = x2 + R * cos(0.5 * pi - alpha), y2 + R * sin(0.5 * pi - alpha),
return (x3, y3), (x4, y4)
# Eric required plot geometry with LaTeX labels
if __name__ == '!__main__':
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt
plt.rcParams["font.family"] = "Times New Roman"
myfontsize = 13.5
plt.rcParams.update({'font.size': myfontsize})
from population import *
im_list = []
with open(r'D:\OneDrive - UW-Madison\c\pop\initial_design.txt', 'r') as f:
for row in csv_row_reader(f):
# fea_config_dict = {}
# fea_config_dict['DPNV'] = True
# fea_config_dict['flag_optimization'] = False
# fea_config_dict['End_Ring_Resistance'] = 0.0
im = bearingless_induction_motor_design([row[0]] + [float(el) for el in row[1:]], None)
im_list.append(im)
# print im.show(toString=True)
# 示意图而已，改改尺寸吧
im.Radius_OuterStatorYoke -= 37
im.Radius_InnerStatorYoke -= 20
im.Radius_Shaft += 20
# im.Location_RotorBarCenter2 += 5 # this will change the shape of rotor slot
vg = VanGogh_pyPlotter(im, CUSTOM)
vg.draw_model()
# PyX
vg.tikz.c = pyx.canvas.canvas() # clear the canvas because we want to redraw 90 deg with the data vg.tikz.track_path
from copy import deepcopy
def pyx_draw_path(vg, path, sign=1):
if len(path) == 4:
vg.tikz.draw_line(path[:2], path[2:4], untrack=True)
else:
vg.tikz.draw_arc(path[:2], path[2:4], path[4:6], relangle=sign * path[6], untrack=True)
def rotate(_, x, y):
return cos(_) * x + sin(_) * y, -sin(_) * x + cos(_) * y
def is_at_stator(im, path):
return sqrt(path[0] ** 2 + path[1] ** 2) > im.Radius_OuterRotor + 0.5 * im.Length_AirGap
# 整体转动90度。
for path in vg.tikz.track_path:
path[0], path[1] = rotate(0.5 * pi, path[0], path[1])
path[2], path[3] = rotate(0.5 * pi, path[2], path[3])
pyx_draw_path(vg, path)
track_path_backup = deepcopy(vg.tikz.track_path)
# Rotate
for path in deepcopy(vg.tikz.track_path):
if is_at_stator(im, path):
Q = im.Qs
else:
Q = im.Qr
_ = 2 * pi / Q
path[0], path[1] = rotate(_, path[0], path[1])
path[2], path[3] = rotate(_, path[2], path[3])
pyx_draw_path(vg, path)
# Mirror
for path in (vg.tikz.track_path): # track_path is passed by reference and is changed by mirror
path[0] *= -1
path[2] *= -1
pyx_draw_path(vg, path, sign=-1)
for path in (vg.tikz.track_path):
if sqrt(path[0] ** 2 + path[1] ** 2) > im.Radius_OuterRotor + 0.5 * im.Length_AirGap:
Q = im.Qs
else:
Q = im.Qr
_ = 2 * pi / Q
path[0], path[1] = rotate(_, path[0], path[1])
path[2], path[3] = rotate(_, path[2], path[3])
pyx_draw_path(vg, path, sign=-1)
def pyx_label_dimention(track_path):
def myarrow(c, PA, PB):
c.stroke(path.line(PA[0], PA[1], PB[0], PB[1]),
[style.linewidth.Thick, style.linestyle.solid, color.rgb.black,
deco.earrow([deco.stroked([color.rgb.black, style.linejoin.round]),
deco.filled([color.rgb.black])], size=0.5)])
def mytext(c, PText, label):
print(PText)
textattrs = [text.halign.center, text.vshift.middlezero, text.size(5), trafo.scale(2)]
handle = text.text(PText[0], PText[1], label, textattrs)
c.insert(handle)
def add_label_inside(c, label, PA, PB, PText=None):
if PText is None:
PText = 0.5 * (PA + PB)
mytext(c, PText, label)
myarrow(c, PA, PB)
myarrow(c, PB, PA)
def add_label_outside(c, label, PA, PB, PText=None, ext_factor=1, left_or_right=True):
vector_AB = np.array((PB[0] - PA[0], PB[1] - PA[1]))
PB, PBExt = PB, PB + vector_AB * ext_factor
myarrow(c, PBExt, PB)
PA, PAExt = PA, PA - vector_AB * ext_factor
myarrow(c, PAExt, PA)
if PText is None:
PText = 0.5 * (PA + PB)
mytext(c, PText, label)
def mymarker(l_PA):
for P in l_PA:
vg.tikz.c.fill(pyx.path.circle(P[0], P[1], 0.25))
count_stator = 0
count_rotor = 0
dictKeyPoints = {}
for ind, el in enumerate(track_path):
if is_at_stator(im, el):
count_stator += 1
print('S-Path' + str(count_stator), el)
dictKeyPoints['S-Path' + str(count_stator)] = el
else:
count_rotor += 1
print('R-Path' + str(count_rotor), el)
dictKeyPoints['R-Path' + str(count_rotor)] = el
# above SP means stator path, below SP means stator point
d = dictKeyPoints # too long to type
RP2 = array(d['R-Path6'][0:2])
RP3 = array(d['R-Path1'][0:2])
RP4 = array(d['R-Path2'][0:2])
RP5 = array(d['R-Path7'][0:2])
RP6 = array(d['R-Path3'][0:2])
RP7 = array(d['R-Path4'][2:4])
SP2 = array(d['S-Path1'][0:2])
SP3 = array(d['S-Path3'][0:2])
SP4 = array(d['S-Path3'][2:4])
SP5 = array(d['S-Path4'][2:4])
_s = 2 * pi / im.Qs
_r = 2 * pi / im.Qr
PA = 0.5 * (SP4 + SP5)
PB = -PA[0], PA[1]
PText = 0.5 * (PA[0] + PB[0]), PA[1] + 1.5
add_label_inside(vg.tikz.c, r'$w_{st}$', PA, PB, PText=PText)
PA = 0.5 * (SP2 + SP3)
PB = rotate(_s, -PA[0], PA[1])
PText = 0.5 * (PA[0] + PB[0]), PA[1] + 1.5
add_label_inside(vg.tikz.c, r'$\theta_{so}$', PA, PB, PText=PText)
PA = SP2
PB = SP3
PA = rotate(-0.9 * _s, PA[0], PA[1])
PB = rotate(-0.9 * _s, PB[0], PB[1])
# PText = 0.5*(PA[0]+PB[0]), PA[1] + 2.25
# add_label_inside(vg.tikz.c, r'$d_{so}$', PA, PB, PText=PText)
PText = 0.5 * (PA[0] + PB[0]), PA[1] + 3
add_label_outside(vg.tikz.c, r'$d_{so}$', PA, PB, PText=PText)
# 辅助线
vg.tikz.c.stroke(path.line(-SP2[0], SP2[1], PA[0], PA[1]),
[style.linewidth(0.08), style.linestyle.dashed, color.gray(0.5)])
vg.tikz.c.stroke(path.line(-SP3[0], SP3[1], PB[0], PB[1]),
[style.linewidth(0.08), style.linestyle.dashed, color.gray(0.5)])
PA = 0.5 * (RP6 + RP7)
PB = rotate(_r, -PA[0], PA[1])
PText = 0.5 * (PA[0] + PB[0]), PA[1] + 1.5
add_label_inside(vg.tikz.c, r'$w_{rt}$', PA, PB, PText=PText)
PA = 0.5 * (RP4 + RP5)
PB = -PA[0], PA[1]
# PText = 0.5*(PA[0]+PB[0]), PA[1] + 1.45
# add_label_inside(vg.tikz.c, r'$w_{ro}$', PA, PB, PText=PText)
PText = 0.5 * (PA[0] + PB[0]) + 3, PA[1] - 0.1
add_label_outside(vg.tikz.c, r'$w_{ro}$', PA, PB, PText=PText)
PA = RP4
PB = RP5
PA = rotate(1.08 * _s, PA[0], PA[1])
PB = rotate(1.08 * _s, PB[0], PB[1])
# PText = 0.5*(PA[0]+PB[0]) - 1.5, PA[1] - 1.
# add_label_inside(vg.tikz.c, r'$d_{ro}$', PA, PB, PText=PText)
PText = 0.5 * (PA[0] + PB[0]) - 1.5, PA[1] - 2
add_label_outside(vg.tikz.c, r'$d_{ro}$', PA, PB, PText=PText)
# 辅助线
RP4 = rotate(_r, RP4[0], RP4[1])
RP5 = rotate(_r, RP5[0], RP5[1])
vg.tikz.c.stroke(path.line(RP4[0], RP4[1], PA[0], PA[1]),
[style.linewidth(0.08), style.linestyle.dashed, color.gray(0.5)])
vg.tikz.c.stroke(path.line(RP5[0], RP5[1], PB[0], PB[1]),
[style.linewidth(0.08), style.linestyle.dashed, color.gray(0.5)])
# Air gap
PA = array([-cos(0.5 * pi - 0.5 * _r), sin(0.5 * pi - 0.5 * _r)]) * im.Radius_OuterRotor
PB = array([-cos(0.5 * pi - 0.5 * _r), sin(0.5 * pi - 0.5 * _r)]) * (im.Radius_OuterRotor + im.Length_AirGap)
PText = 0.5 * (PA[0] + PB[0]), PA[1] - 1
add_label_inside(vg.tikz.c, r'$L_{g}$', PA, PB, PText=PText)
# Outer Rotor Diameter
PA = array([cos(0.5 * pi - 0.5 * _r), sin(0.5 * pi - 0.5 * _r)]) * im.Radius_OuterRotor
PB = array([cos(0.5 * pi - 0.5 * _r), sin(0.5 * pi - 0.5 * _r)]) * (im.Radius_OuterRotor * 0.975)
PText = PA[0] + 1.2, PA[1] - 1.5
myarrow(vg.tikz.c, PB, PA)
mytext(vg.tikz.c, PText, r'$r_{or}$')
# Outer Sator Diameter
PA = array([cos(0.5 * pi - 0.5 * _r), sin(0.5 * pi - 0.5 * _r)]) * im.Radius_OuterStatorYoke
PB = array([cos(0.5 * pi - 0.5 * _r), sin(0.5 * pi - 0.5 * _r)]) * (im.Radius_OuterStatorYoke * 0.975)
PText = PA[0] - 1.5, PA[1] - 1.5
myarrow(vg.tikz.c, PB, PA)
mytext(vg.tikz.c, PText, r'$r_{os}$')
# mymarker([PA, PB, PText])
# print dir(color.rgb)
# print dir(style.linestyle)
# vg.tikz.c.stroke(path.line(0, 0, 0, 40),
# [style.linewidth.THICK, style.linestyle.solid, color.gray(0.5),
# deco.earrow([deco.stroked([color.rgb.black, style.linejoin.round]),
# deco.filled([color.rgb.black])], size=0.5)])
from pyx import *
pyx_label_dimention(track_path_backup)
vg.tikz.c.writePDFfile("pyx_output")
# vg.tikz.c.writeEPSfile("pyx_output")
print('Write to pdf file: pyx_output.pdf.')
quit()
# 以下应该是旧代码，用matplotlib画电机二维截面
BIAS = 1
Stator_Sector_Angle = 2 * pi / im.Qs * 0.5
Rotor_Sector_Angle = 2 * pi / im.Qr * 0.5
# draw the mirrored slot
new_objs = []
for obj in vg.rotor_object_list:
xy_data = obj.get_xydata().T
new_obj = vg.ax.plot(xy_data[0], -array(xy_data[1]), 'k-', zorder=0) # 'k--'
new_objs.append(new_obj[0])
vg.rotor_object_list += new_objs
new_objs = []
for obj in vg.stator_object_list:
xy_data = obj.get_xydata().T
new_obj = vg.ax.plot(xy_data[0], -array(xy_data[1]), 'k-', zorder=0) # 'k--'
new_objs.append(new_obj[0])
vg.stator_object_list += new_objs
# draw the rotated slot
# rotor
angle = Rotor_Sector_Angle * 2
TR = array([[cos(angle), sin(angle)],
[-sin(angle), cos(angle)]])
for obj in vg.rotor_object_list:
xy_data = obj.get_xydata().T
xy_data_rot = np.dot(TR, xy_data)
# xy_data_rot = xy_data_rot.T
vg.ax.plot(xy_data_rot[0], xy_data_rot[1], 'k-', zorder=0) # 'k--'
# stator
angle = Stator_Sector_Angle * 2
TS = array([[cos(angle), sin(angle)],
[-sin(angle), cos(angle)]])
for obj in vg.stator_object_list:
xy_data = obj.get_xydata().T
xy_data_rot = np.dot(TS, xy_data)
# xy_data_rot = xy_data_rot.T
vg.ax.plot(xy_data_rot[0], xy_data_rot[1], 'k-', zorder=0) # 'k--'
################################################################
# add labels to geometry
################################################################
# xy = (-0.5*(im.Location_RotorBarCenter+im.Location_RotorBarCenter2), 2.5)
# vg.ax.annotate('Parallel tooth', xytext=(xy[0],-(xy[1]+5)), xy=(xy[0],-xy[1]), xycoords='data', arrowprops=dict(arrowstyle="->"),fontsize=24,rotation=90)
xy = (-im.Radius_OuterStatorYoke, 0)
vg.ax.annotate(r'$D_{os}$', xytext=(xy[0] + 2.5, xy[1] - 0.25), xy=xy, xycoords='data',
arrowprops=dict(arrowstyle="->"), fontsize=24, rotation=90)
xy = (-im.Radius_OuterRotor, -4)
vg.ax.annotate(r'$D_{or}$', xytext=(xy[0] + 2.5, xy[1] - 0.25), xy=xy, xycoords='data',
arrowprops=dict(arrowstyle="->"), fontsize=24, rotation=90)
xy = (-im.Radius_Shaft, 0)
vg.ax.annotate(r'$D_{ir}$', xytext=(xy[0] + 2.5, xy[1] - 0.25), xy=xy, xycoords='data',
arrowprops=dict(arrowstyle="->"), fontsize=24, rotation=90)
vg.ax.set_xlim([-74, -45])
def add_label_inside(vg, label, PA, PB):
# vector_AB = (PB[0]-PA[0], PB[1]-PA[1])
xy, xytext = PA, PB
vg.ax.annotate('', xytext=xytext, xy=xy, xycoords='data', arrowprops=dict(arrowstyle="->"), fontsize=24,
rotation=90)
xy, xytext = xytext, xy
vg.ax.annotate('', xytext=xytext, xy=xy, xycoords='data', arrowprops=dict(arrowstyle="->"), fontsize=24,
rotation=90)
vg.ax.text(0.5 + 0.5 * (xy[0] + xytext[0]), 0. + 0.5 * (xy[1] + xytext[1]), label, fontsize=24, rotation=90,
bbox=dict(facecolor='w', edgecolor='w', boxstyle='round,pad=0', alpha=0.9))
def add_label_outside(vg, label, PA, PB, ext_factor=1, left_or_right=True):
vector_AB = np.array((PB[0] - PA[0], PB[1] - PA[1]))
xy, xytext = PB, PB + vector_AB * ext_factor
vg.ax.annotate('', xytext=xytext, xy=xy, xycoords='data', arrowprops=dict(arrowstyle="->"), fontsize=24,
rotation=90)
xy, xytext = PA, PA - vector_AB * ext_factor
vg.ax.annotate('', xytext=xytext, xy=xy, xycoords='data', arrowprops=dict(arrowstyle="->"), fontsize=24,
rotation=90)
if left_or_right:
vg.ax.text(0.5 + PB[0], -1.75 + PB[1], label, fontsize=24, rotation=90,
bbox=dict(facecolor='w', edgecolor='w', boxstyle='round,pad=0', alpha=0.9))
else:
vg.ax.text(0.5 + PB[0], +1.75 + PB[1], label, fontsize=24, rotation=90,
bbox=dict(facecolor='w', edgecolor='w', boxstyle='round,pad=0', alpha=0.9))
def add_extension_line(vg, P, vector_ext, distance_factor=1):
distance = sqrt(vector_ext[0] ** 2 + vector_ext[1] ** 2)
vector_ext /= distance / distance_factor # a unit vector * distance_factor
x = [P[0], P[0] + vector_ext[0]]
y = [P[1], P[1] + vector_ext[1]]
vg.ax.plot(x, y, 'k-', lw=0.6)
return vector_ext
# 1
Ps2 = vg.Ps_list[2 - BIAS] * array((1, -1)) # mirror
Ptemp1 = Ps2[0], Ps2[1] - 5
Ptemp1 = vg.park_transform(Ptemp1,
-Stator_Sector_Angle) # this is not exact but close enough, you can find the exact point by solve a triangle with Radius_OuterRotor + Length_AirGap from Pr3
vector_ext = np.array((Ptemp1[0] - Ps2[0], Ptemp1[1] - Ps2[1]))
vector_ext = add_extension_line(vg, Ps2, vector_ext, distance_factor=2.5)
Ptemp1 = (Ps2 + 0.5 * vector_ext)
Pr3 = vg.Pr_list[3 - BIAS] * array((1, -1)) # mirror
Ptemp2 = array((Pr3[0], Pr3[1] - 5))
Ptemp2 = vg.park_transform(Ptemp2, -Rotor_Sector_Angle)
vector_ext = np.array((Ptemp2[0] - Pr3[0], Ptemp2[1] - Pr3[1]))
vector_ext = add_extension_line(vg, Pr3, vector_ext, distance_factor=2.5)
Ptemp2 = (Pr3 + 0.8 * vector_ext) # change this factor before vector_ext to rotate the label
add_label_outside(vg, r'$L_g$', Ptemp1, Ptemp2, ext_factor=2)
# 2
Ps4 = vg.Ps_list[4 - BIAS]
Ps5 = vg.Ps_list[5 - BIAS]
Ptemp = 0.5 * (Ps4 + Ps5)
add_label_inside(vg, r'$W_{\rm st}$', (Ptemp[0], -Ptemp[1]), Ptemp)
# 3
Pr6 = array(vg.Pr_list[6 - BIAS])
Pr7 = array(vg.Pr_list[7 - BIAS])
Ptemp2 = 0.5 * (Pr6 + Pr7) # middle point
Ptemp1 = Ptemp2[0], -Ptemp2[1] # mirror
Ptemp1 = np.dot(TR, Ptemp1) # rotate
# vector_r67 = Pr7 - Pr6
# vector_r67_perpendi = (-vector_r67[1], vector_r67[0])
# some_angle = atan2(vector_r67[1], vector_r67[0])
add_label_inside(vg, r'$W_{\rm rt}$', Ptemp1, Ptemp2)
# 4 (This one is angle, so we add text independently)
Ps3 = vg.Ps_list[3 - BIAS]
Ptemp1 = Ps3 * np.array((1, -1)) # mirror
Ptemp2 = np.dot(TS, Ptemp1) # rotate
if False: # treat it as width
add_label_inside(vg, r'$w_{\rm open,s}$', Ps3, Ptemp2)
else: # it is an angle, ok.
Ps2 = vg.Ps_list[2 - BIAS]
vector_ext = Ps3 - Ps2
vector_ext = add_extension_line(vg, Ps3, vector_ext, distance_factor=3)
Ptemp1 = (Ps3 + 0.5 * vector_ext)
vector_ext *= array([1, -1]) # mirror
vector_ext = np.dot(TS, vector_ext) # rotate
vector_ext = add_extension_line(vg, Ptemp2, vector_ext, distance_factor=3)
Ptemp2 = (Ptemp2 + 0.5 * vector_ext)
some_angle = atan2(vector_ext[1], vector_ext[0])
print(some_angle / pi * 180, 180 - Stator_Sector_Angle / pi * 180)
vg.pyplot_arc(im.Radius_OuterRotor + im.Length_AirGap + im.Width_StatorTeethHeadThickness + 2,
angle_span=0.95 * im.Angle_StatorSlotOpen / 180 * pi,
rotation=some_angle - 0.475 * im.Angle_StatorSlotOpen / 180 * pi, center=(0, 0), lw=0.6)
# vg.ax.text(Ptemp1[0], Ptemp1[1], r'$w_{\rm open,s}$',fontsize=24,rotation=90,
# bbox=dict(facecolor='w', edgecolor='r',boxstyle='round,pad=0',alpha=0.9))
vg.ax.text(0.5 * (Ptemp1[0] + Ptemp2[0]) - 5, 0.5 * (Ptemp1[1] + Ptemp2[1]), r'$\theta_{\rm so}$', fontsize=24,
rotation=90,
bbox=dict(facecolor='w', edgecolor='w', boxstyle='round,pad=0', alpha=0.9))
# 5
Pr4 = vg.Pr_list[4 - BIAS]
Pr5 = vg.Pr_list[5 - BIAS]
Ptemp1 = 0.5 * (Pr4 + Pr5)
Ptemp2 = Ptemp1 * np.array((1, -1)) # mirror
add_label_outside(vg, r'$W_{\rm ro}$', Ptemp1, Ptemp2, ext_factor=2, left_or_right=False)
# 6
Ps2 = vg.Ps_list[2 - BIAS]
Ps3 = vg.Ps_list[3 - BIAS]
Ptemp1 = np.dot(TS, Ps2)
Ptemp11 = np.dot(TS, Ps3)
vector_ext = -np.array((Ptemp11[0] - Ptemp1[0], Ptemp11[1] - Ptemp1[1]))
vector_ext = np.array((-vector_ext[1], vector_ext[0]))
vector_ext = add_extension_line(vg, Ptemp1, vector_ext, distance_factor=1)
Ptemp1 = (Ptemp1 + 0.5 * vector_ext)
Ptemp2 = np.dot(TS, Ps3)
Ptemp22 = np.dot(TS, Ps2)
vector_ext = np.array((Ptemp22[0] - Ptemp2[0], Ptemp22[1] - Ptemp2[1]))
vector_ext = np.array((-vector_ext[1], vector_ext[0]))
vector_ext = add_extension_line(vg, Ptemp2, vector_ext, distance_factor=1)
Ptemp2 = (Ptemp2 + 0.5 * vector_ext)
add_label_outside(vg, r'$d_{\rm so}$', Ptemp1, Ptemp2, ext_factor=3)
# 7
Pr4 = vg.Pr_list[4 - BIAS]
Ptemp1 = np.dot(TR, Pr4)
Ptemp11 = np.array((Pr4[0], Pr4[1] + 5))
Ptemp11 = np.dot(TR, Ptemp11)
vector_ext = np.array((Ptemp11[0] - Ptemp1[0], Ptemp11[1] - Ptemp1[1]))
vector_ext = add_extension_line(vg, Ptemp1, vector_ext, distance_factor=6)
Ptemp1 = (Ptemp1 + 0.5 * vector_ext)
Pr5 = vg.Pr_list[5 - BIAS]
Ptemp2 = np.dot(TR, Pr5)
Ptemp22 = np.array((Pr5[0], Pr5[1] + 5))
Ptemp22 = np.dot(TR, Ptemp22)
vector_ext = np.array((Ptemp22[0] - Ptemp2[0], Ptemp22[1] - Ptemp2[1]))
vector_ext = add_extension_line(vg, Ptemp2, vector_ext, distance_factor=6)
Ptemp2 = (Ptemp2 + 0.5 * vector_ext)
add_label_outside(vg, r'$d_{\rm ro}$', Ptemp1, Ptemp2, ext_factor=3)
vg.ax.get_xaxis().set_visible(False)
vg.ax.get_yaxis().set_visible(False)
vg.fig.tight_layout()
# vg.fig.savefig(r'D:\OneDrive\[00]GetWorking\32 blimopti\p2019_ecce_bearingless_induction_full_paper\images\CAD_CrossSection.png')
vg.fig.savefig(
r'D:\OneDrive\[00]GetWorking\31 Bearingless_Induction_FEA_Model\p2019_iemdc_bearingless_induction full paper\images\CAD_CrossSection_Rot.png')
show()
quit()
# My plot geometry with LaTeX labels
if __name__ == '!__main__':
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt
import numpy as np
plt.rcParams["font.family"] = "Times New Roman"
myfontsize = 13.5
plt.rcParams.update({'font.size': myfontsize})
from population import *
im_list = []
with open(r'D:\OneDrive - UW-Madison\c\pop\initial_design.txt', 'r') as f:
for row in csv_row_reader(f):
im = bearingless_induction_motor_design([row[0]] + [float(el) for el in row[1:]], None)
im_list.append(im)
# print im.show(toString=True)
# 示意图而已，改改尺寸吧
im.Radius_OuterStatorYoke -= 25
im.Radius_InnerStatorYoke -= 20
im.Radius_Shaft += 10
vg = VanGogh_pyPlotter(im, CUSTOM)
vg.draw_model()
#
BIAS = 1
Stator_Sector_Angle = 2 * pi / im.Qs * 0.5
Rotor_Sector_Angle = 2 * pi / im.Qr * 0.5
# draw the mirrored slot
new_objs = []
for obj in vg.rotor_object_list:
xy_data = obj.get_xydata().T
new_obj = vg.ax.plot(xy_data[0], -array(xy_data[1]), 'k-', zorder=0) # 'k--'
new_objs.append(new_obj[0])
vg.rotor_object_list += new_objs
new_objs = []
for obj in vg.stator_object_list:
xy_data = obj.get_xydata().T
new_obj = vg.ax.plot(xy_data[0], -array(xy_data[1]), 'k-', zorder=0) # 'k--'
new_objs.append(new_obj[0])
vg.stator_object_list += new_objs
# draw the rotated slot
# rotor
angle = Rotor_Sector_Angle * 2
TR = array([[cos(angle), sin(angle)],
[-sin(angle), cos(angle)]])
for obj in vg.rotor_object_list:
xy_data = obj.get_xydata().T
xy_data_rot = np.dot(TR, xy_data)
# xy_data_rot = xy_data_rot.T
vg.ax.plot(xy_data_rot[0], xy_data_rot[1], 'k-', zorder=0) # 'k--'
# stator
angle = Stator_Sector_Angle * 2
TS = array([[cos(angle), sin(angle)],
[-sin(angle), cos(angle)]])
for obj in vg.stator_object_list:
xy_data = obj.get_xydata().T
xy_data_rot = np.dot(TS, xy_data)
# xy_data_rot = xy_data_rot.T
vg.ax.plot(xy_data_rot[0], xy_data_rot[1], 'k-', zorder=0) # 'k--'
################################################################
# add labels to geometry
################################################################
# xy = (-0.5*(im.Location_RotorBarCenter+im.Location_RotorBarCenter2), 2.5)
# vg.ax.annotate('Parallel tooth', xytext=(xy[0],-(xy[1]+5)), xy=(xy[0],-xy[1]), xycoords='data', arrowprops=dict(arrowstyle="->"))
xy = (-im.Radius_OuterStatorYoke, 0)
vg.ax.annotate(r'$r_{so}=86.9$ mm', xytext=(xy[0] + 2.5, xy[1] - 0.25), xy=xy, xycoords='data',
arrowprops=dict(arrowstyle="->"))
xy = (-im.Radius_OuterRotor, -4)
vg.ax.annotate(r'$r_{ro}=47.1$ mm', xytext=(xy[0] + 2.5, xy[1] - 0.25), xy=xy, xycoords='data',
arrowprops=dict(arrowstyle="->"))
def add_label_inside(vg, label, PA, PB):
# vector_AB = (PB[0]-PA[0], PB[1]-PA[1])
xy, xytext = PA, PB
vg.ax.annotate('', xytext=xytext, xy=xy, xycoords='data', arrowprops=dict(arrowstyle="->"))
xy, xytext = xytext, xy
vg.ax.annotate('', xytext=xytext, xy=xy, xycoords='data', arrowprops=dict(arrowstyle="->"))
vg.ax.text(0.5 + 0.5 * (xy[0] + xytext[0]), 0. + 0.5 * (xy[1] + xytext[1]), label,
bbox=dict(facecolor='w', edgecolor='r', boxstyle='round,pad=0', alpha=0.9))
def add_label_outside(vg, label, PA, PB, ext_factor=1):
vector_AB = np.array((PB[0] - PA[0], PB[1] - PA[1]))
xy, xytext = PB, PB + vector_AB * ext_factor
vg.ax.annotate('', xytext=xytext, xy=xy, xycoords='data', arrowprops=dict(arrowstyle="->"))
xy, xytext = PA, PA - vector_AB * ext_factor
vg.ax.annotate('', xytext=xytext, xy=xy, xycoords='data', arrowprops=dict(arrowstyle="->"))
vg.ax.text(0.5 + PB[0], -1.75 + PB[1], label,
bbox=dict(facecolor='w', edgecolor='r', boxstyle='round,pad=0', alpha=0.9))
def add_extension_line(vg, P, vector_ext, distance_factor=1):
distance = sqrt(vector_ext[0] ** 2 + vector_ext[1] ** 2)
vector_ext /= distance / distance_factor # a unit vector * distance_factor
x = [P[0], P[0] + vector_ext[0]]
y = [P[1], P[1] + vector_ext[1]]
vg.ax.plot(x, y, 'k-', lw=0.6)
return vector_ext
# 1
Ps2 = vg.Ps_list[2 - BIAS] * array((1, -1)) # mirror
Ptemp1 = Ps2[0], Ps2[1] - 5
Ptemp1 = vg.park_transform(Ptemp1,
-Stator_Sector_Angle) # this is not exact but close enough, you can find the exact point by solve a triangle with Radius_OuterRotor + Length_AirGap from Pr3
vector_ext = np.array((Ptemp1[0] - Ps2[0], Ptemp1[1] - Ps2[1]))
vector_ext = add_extension_line(vg, Ps2, vector_ext, distance_factor=2.5)
Ptemp1 = (Ps2 + 0.5 * vector_ext)
Pr3 = vg.Pr_list[3 - BIAS] * array((1, -1)) # mirror
Ptemp2 = array((Pr3[0], Pr3[1] - 5))
Ptemp2 = vg.park_transform(Ptemp2, -Rotor_Sector_Angle)
vector_ext = np.array((Ptemp2[0] - Pr3[0], Ptemp2[1] - Pr3[1]))
vector_ext = add_extension_line(vg, Pr3, vector_ext, distance_factor=2.5)
Ptemp2 = (Pr3 + 0.5 * vector_ext)
add_label_outside(vg, r'$\delta$', Ptemp1, Ptemp2, ext_factor=2)
# 2
Ps4 = vg.Ps_list[4 - BIAS]
Ps5 = vg.Ps_list[5 - BIAS]
Ptemp = 0.5 * (Ps4 + Ps5)
add_label_inside(vg, r'$b_{\rm tooth,s}$', (Ptemp[0], -Ptemp[1]), Ptemp)
# 3
Pr6 = array(vg.Pr_list[6 - BIAS])
Pr7 = array(vg.Pr_list[7 - BIAS])
Ptemp2 = 0.5 * (Pr6 + Pr7) # middle point
Ptemp1 = Ptemp2[0], -Ptemp2[1] # mirror
Ptemp1 = np.dot(TR, Ptemp1) # rotate
# vector_r67 = Pr7 - Pr6
# vector_r67_perpendi = (-vector_r67[1], vector_r67[0])
# some_angle = atan2(vector_r67[1], vector_r67[0])
add_label_inside(vg, r'$b_{\rm tooth,r}$', Ptemp1, Ptemp2)
# 4 (This one is angle)
Ps3 = vg.Ps_list[3 - BIAS]
Ptemp1 = Ps3 * np.array((1, -1)) # mirror
Ptemp2 = np.dot(TS, Ptemp1) # rotate
if False: # treat it as width
add_label_inside(vg, r'$w_{\rm open,s}$', Ps3, Ptemp2)
else: # it is an angle, ok.
Ps2 = vg.Ps_list[2 - BIAS]
vector_ext = Ps3 - Ps2
vector_ext = add_extension_line(vg, Ps3, vector_ext, distance_factor=3)
Ptemp1 = (Ps3 + 0.5 * vector_ext)
vector_ext *= array([1, -1]) # mirror
vector_ext = np.dot(TS, vector_ext) # rotate
vector_ext = add_extension_line(vg, Ptemp2, vector_ext, distance_factor=3)
Ptemp2 = (Ptemp2 + 0.5 * vector_ext)
some_angle = atan2(vector_ext[1], vector_ext[0])
print(some_angle / pi * 180, 180 - Stator_Sector_Angle / pi * 180)
vg.pyplot_arc(im.Radius_OuterRotor + im.Length_AirGap + im.Width_StatorTeethHeadThickness + 2,
angle_span=0.95 * im.Angle_StatorSlotOpen / 180 * pi,
rotation=some_angle - 0.475 * im.Angle_StatorSlotOpen / 180 * pi, center=(0, 0), lw=0.6)
# vg.ax.text(Ptemp1[0], Ptemp1[1], r'$w_{\rm open,s}$',
# bbox=dict(facecolor='w', edgecolor='r',boxstyle='round,pad=0',alpha=0.9))
vg.ax.text(0.5 * (Ptemp1[0] + Ptemp2[0]) - 5, 0.5 * (Ptemp1[1] + Ptemp2[1]), r'$w_{\rm open,s}$',
bbox=dict(facecolor='w', edgecolor='r', boxstyle='round,pad=0', alpha=0.9))
# 5
Pr4 = vg.Pr_list[4 - BIAS]
Pr5 = vg.Pr_list[5 - BIAS]
Ptemp1 = 0.5 * (Pr4 + Pr5)
Ptemp2 = Ptemp1 * np.array((1, -1)) # mirror
add_label_outside(vg, r'$w_{\rm open,r}$', Ptemp1, Ptemp2, ext_factor=2)
# 6
Ps2 = vg.Ps_list[2 - BIAS]
Ps3 = vg.Ps_list[3 - BIAS]
Ptemp1 = np.dot(TS, Ps2)
Ptemp11 = np.dot(TS, Ps3)
vector_ext = -np.array((Ptemp11[0] - Ptemp1[0], Ptemp11[1] - Ptemp1[1]))
vector_ext = np.array((-vector_ext[1], vector_ext[0]))
vector_ext = add_extension_line(vg, Ptemp1, vector_ext, distance_factor=1)
Ptemp1 = (Ptemp1 + 0.5 * vector_ext)
Ptemp2 = np.dot(TS, Ps3)
Ptemp22 = np.dot(TS, Ps2)
vector_ext = np.array((Ptemp22[0] - Ptemp2[0], Ptemp22[1] - Ptemp2[1]))
vector_ext = np.array((-vector_ext[1], vector_ext[0]))
vector_ext = add_extension_line(vg, Ptemp2, vector_ext, distance_factor=1)
Ptemp2 = (Ptemp2 + 0.5 * vector_ext)
add_label_outside(vg, r'$h_{\rm head,s}$', Ptemp1, Ptemp2, ext_factor=3)
# 7
Pr4 = vg.Pr_list[4 - BIAS]
Ptemp1 = np.dot(TR, Pr4)
Ptemp11 = np.array((Pr4[0], Pr4[1] + 5))
Ptemp11 = np.dot(TR, Ptemp11)
vector_ext = np.array((Ptemp11[0] - Ptemp1[0], Ptemp11[1] - Ptemp1[1]))
vector_ext = add_extension_line(vg, Ptemp1, vector_ext, distance_factor=6)
Ptemp1 = (Ptemp1 + 0.5 * vector_ext)
Pr5 = vg.Pr_list[5 - BIAS]
Ptemp2 = np.dot(TR, Pr5)
Ptemp22 = np.array((Pr5[0], Pr5[1] + 5))
Ptemp22 = np.dot(TR, Ptemp22)
vector_ext = | np.array((Ptemp22[0] - Ptemp2[0], Ptemp22[1] - Ptemp2[1])) | numpy.array |
#!/usr/bin/env python
from pyiri2016 import IRI2016,IRI2016Profile
from numpy import arange
from matplotlib.pyplot import figure, legend, show
import seaborn
def example02():
""" Geog. Latitude Profile Example """
latlim = [-60, 60]
latstp = 2.
iri2016Obj = IRI2016Profile(alt=600, hour=17., latlim=latlim, latstp=latstp, \
lon=-76.77, option=2, verbose=False, year=2004)
latbins = | arange(latlim[0], latlim[1] + latstp, latstp) | numpy.arange |
# Copyright 2018-2020 Xanadu Quantum Technologies Inc.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Unit tests for the available built-in discrete-variable quantum operations.
"""
import pytest
import functools
import numpy as np
from numpy.linalg import multi_dot
from scipy.linalg import block_diag
import pennylane as qml
from pennylane.templates.layers import StronglyEntanglingLayers
from gate_data import I, X, Y, Z, H, CNOT, SWAP, CZ, S, T, CSWAP, Toffoli
# Standard observables, their matrix representation, and eigenvlaues
OBSERVABLES = [
(qml.PauliX, X, [1, -1]),
(qml.PauliY, Y, [1, -1]),
(qml.PauliZ, Z, [1, -1]),
(qml.Hadamard, H, [1, -1]),
(qml.Identity, I, [1, 1]),
]
# Hermitian matrices, their corresponding eigenvalues and eigenvectors.
EIGVALS_TEST_DATA = [
(np.array([[1, 0], [0, 1]]), np.array([1.0, 1.0]), np.array([[1.0, 0.0], [0.0, 1.0]])),
(
np.array([[0, 1], [1, 0]]),
np.array([-1.0, 1.0]),
np.array([[-0.70710678, 0.70710678], [0.70710678, 0.70710678]]),
),
(
np.array([[0, -1j], [1j, 0]]),
np.array([-1.0, 1.0]),
np.array(
[[-0.70710678 + 0.0j, -0.70710678 + 0.0j], [0.0 + 0.70710678j, 0.0 - 0.70710678j]]
),
),
(np.array([[1, 0], [0, -1]]), np.array([-1.0, 1.0]), np.array([[0.0, 1.0], [1.0, 0.0]])),
(
1 / np.sqrt(2) * np.array([[1, 1], [1, -1]]),
np.array([-1.0, 1.0]),
np.array([[0.38268343, -0.92387953], [-0.92387953, -0.38268343]]),
),
]
EIGVALS_TEST_DATA_MULTI_WIRES = [
functools.reduce(np.kron, [Y, I, Z])
]
@pytest.mark.usefixtures("tear_down_hermitian")
class TestObservables:
"""Tests for observables"""
@pytest.mark.parametrize("obs, mat, eigs", OBSERVABLES)
def test_diagonalization(self, obs, mat, eigs, tol):
"""Test the method transforms standard observables into the Z-gate."""
ob = obs(wires=0)
A = ob.matrix
diag_gates = ob.diagonalizing_gates()
U = np.eye(2)
if diag_gates:
mats = [i.matrix for i in diag_gates]
# Need to revert the order in which the matrices are applied such that they adhere to the order
# of matrix multiplication
# E.g. for PauliY: [PauliZ(wires=self.wires), S(wires=self.wires), Hadamard(wires=self.wires)]
# becomes Hadamard @ S @ PauliZ, where @ stands for matrix multiplication
mats = mats[::-1]
U = multi_dot([np.eye(2)] + mats)
res = U @ A @ U.conj().T
expected = np.diag(eigs)
assert np.allclose(res, expected, atol=tol, rtol=0)
@pytest.mark.parametrize("obs, mat, eigs", OBSERVABLES)
def test_eigvals(self, obs, mat, eigs, tol):
"""Test eigenvalues of standard observables are correct"""
obs = obs(wires=0)
res = obs.eigvals
assert np.allclose(res, eigs, atol=tol, rtol=0)
@pytest.mark.parametrize("obs, mat, eigs", OBSERVABLES)
def test_matrices(self, obs, mat, eigs, tol):
"""Test matrices of standard observables are correct"""
obs = obs(wires=0)
res = obs.matrix
assert np.allclose(res, mat, atol=tol, rtol=0)
@pytest.mark.parametrize("observable, eigvals, eigvecs", EIGVALS_TEST_DATA)
def test_hermitian_eigegendecomposition_single_wire(
self, observable, eigvals, eigvecs, tol
):
"""Tests that the eigendecomposition property of the Hermitian class returns the correct results
for a single wire."""
eigendecomp = qml.Hermitian(observable, wires=0).eigendecomposition
assert np.allclose(eigendecomp["eigval"], eigvals, atol=tol, rtol=0)
assert np.allclose(eigendecomp["eigvec"], eigvecs, atol=tol, rtol=0)
key = tuple(observable.flatten().tolist())
assert np.allclose(qml.Hermitian._eigs[key]["eigval"], eigvals, atol=tol, rtol=0)
assert np.allclose(qml.Hermitian._eigs[key]["eigvec"], eigvecs, atol=tol, rtol=0)
assert len(qml.Hermitian._eigs) == 1
@pytest.mark.parametrize("observable", EIGVALS_TEST_DATA_MULTI_WIRES)
def test_hermitian_eigegendecomposition_multiple_wires(
self, observable, tol
):
"""Tests that the eigendecomposition property of the Hermitian class returns the correct results
for multiple wires."""
num_wires = int(np.log2(len(observable)))
eigendecomp = qml.Hermitian(observable, wires=list(range(num_wires))).eigendecomposition
eigvals, eigvecs = np.linalg.eigh(observable)
assert np.allclose(eigendecomp["eigval"], eigvals, atol=tol, rtol=0)
assert np.allclose(eigendecomp["eigvec"], eigvecs, atol=tol, rtol=0)
key = tuple(observable.flatten().tolist())
assert np.allclose(qml.Hermitian._eigs[key]["eigval"], eigvals, atol=tol, rtol=0)
assert np.allclose(qml.Hermitian._eigs[key]["eigvec"], eigvecs, atol=tol, rtol=0)
assert len(qml.Hermitian._eigs) == 1
@pytest.mark.parametrize("obs1", EIGVALS_TEST_DATA)
@pytest.mark.parametrize("obs2", EIGVALS_TEST_DATA)
def test_hermitian_eigvals_eigvecs_two_different_observables(self, obs1, obs2, tol):
"""Tests that the eigvals method of the Hermitian class returns the correct results
for two observables."""
if np.all(obs1[0] == obs2[0]):
pytest.skip("Test only runs for pairs of differing observable")
observable_1 = obs1[0]
observable_1_eigvals = obs1[1]
observable_1_eigvecs = obs1[2]
key = tuple(observable_1.flatten().tolist())
qml.Hermitian(observable_1, 0).eigvals
assert np.allclose(
qml.Hermitian._eigs[key]["eigval"], observable_1_eigvals, atol=tol, rtol=0
)
assert np.allclose(
qml.Hermitian._eigs[key]["eigvec"], observable_1_eigvecs, atol=tol, rtol=0
)
assert len(qml.Hermitian._eigs) == 1
observable_2 = obs2[0]
observable_2_eigvals = obs2[1]
observable_2_eigvecs = obs2[2]
key_2 = tuple(observable_2.flatten().tolist())
qml.Hermitian(observable_2, 0).eigvals
assert np.allclose(
qml.Hermitian._eigs[key_2]["eigval"], observable_2_eigvals, atol=tol, rtol=0
)
assert np.allclose(
qml.Hermitian._eigs[key_2]["eigvec"], observable_2_eigvecs, atol=tol, rtol=0
)
assert len(qml.Hermitian._eigs) == 2
@pytest.mark.parametrize("observable, eigvals, eigvecs", EIGVALS_TEST_DATA)
def test_hermitian_eigvals_eigvecs_same_observable_twice(
self, observable, eigvals, eigvecs, tol
):
"""Tests that the eigvals method of the Hermitian class keeps the same dictionary entries upon multiple calls."""
key = tuple(observable.flatten().tolist())
qml.Hermitian(observable, 0).eigvals
assert np.allclose(qml.Hermitian._eigs[key]["eigval"], eigvals, atol=tol, rtol=0)
assert np.allclose(qml.Hermitian._eigs[key]["eigvec"], eigvecs, atol=tol, rtol=0)
assert len(qml.Hermitian._eigs) == 1
qml.Hermitian(observable, 0).eigvals
assert np.allclose(qml.Hermitian._eigs[key]["eigval"], eigvals, atol=tol, rtol=0)
assert np.allclose(qml.Hermitian._eigs[key]["eigvec"], eigvecs, atol=tol, rtol=0)
assert len(qml.Hermitian._eigs) == 1
@pytest.mark.parametrize("observable, eigvals, eigvecs", EIGVALS_TEST_DATA)
def test_hermitian_diagonalizing_gates(self, observable, eigvals, eigvecs, tol):
"""Tests that the diagonalizing_gates method of the Hermitian class returns the correct results."""
qubit_unitary = qml.Hermitian(observable, wires=[0]).diagonalizing_gates()
key = tuple(observable.flatten().tolist())
assert np.allclose(qml.Hermitian._eigs[key]["eigval"], eigvals, atol=tol, rtol=0)
assert np.allclose(qml.Hermitian._eigs[key]["eigvec"], eigvecs, atol=tol, rtol=0)
assert np.allclose(qubit_unitary[0].params, eigvecs.conj().T, atol=tol, rtol=0)
assert len(qml.Hermitian._eigs) == 1
@pytest.mark.parametrize("obs1", EIGVALS_TEST_DATA)
@pytest.mark.parametrize("obs2", EIGVALS_TEST_DATA)
def test_hermitian_diagonalizing_gates_two_different_observables(self, obs1, obs2, tol):
"""Tests that the diagonalizing_gates method of the Hermitian class returns the correct results
for two observables."""
if np.all(obs1[0] == obs2[0]):
pytest.skip("Test only runs for pairs of differing observable")
observable_1 = obs1[0]
observable_1_eigvals = obs1[1]
observable_1_eigvecs = obs1[2]
qubit_unitary = qml.Hermitian(observable_1, wires=[0]).diagonalizing_gates()
key = tuple(observable_1.flatten().tolist())
assert np.allclose(
qml.Hermitian._eigs[key]["eigval"], observable_1_eigvals, atol=tol, rtol=0
)
assert np.allclose(
qml.Hermitian._eigs[key]["eigvec"], observable_1_eigvecs, atol=tol, rtol=0
)
assert np.allclose(qubit_unitary[0].params, observable_1_eigvecs.conj().T, atol=tol, rtol=0)
assert len(qml.Hermitian._eigs) == 1
observable_2 = obs2[0]
observable_2_eigvals = obs2[1]
observable_2_eigvecs = obs2[2]
qubit_unitary_2 = qml.Hermitian(observable_2, wires=[0]).diagonalizing_gates()
key = tuple(observable_2.flatten().tolist())
assert np.allclose(
qml.Hermitian._eigs[key]["eigval"], observable_2_eigvals, atol=tol, rtol=0
)
assert np.allclose(
qml.Hermitian._eigs[key]["eigvec"], observable_2_eigvecs, atol=tol, rtol=0
)
assert np.allclose(
qubit_unitary_2[0].params, observable_2_eigvecs.conj().T, atol=tol, rtol=0
)
assert len(qml.Hermitian._eigs) == 2
@pytest.mark.parametrize("observable, eigvals, eigvecs", EIGVALS_TEST_DATA)
def test_hermitian_diagonalizing_gatesi_same_observable_twice(
self, observable, eigvals, eigvecs, tol
):
"""Tests that the diagonalizing_gates method of the Hermitian class keeps the same dictionary entries upon multiple calls."""
qubit_unitary = qml.Hermitian(observable, wires=[0]).diagonalizing_gates()
key = tuple(observable.flatten().tolist())
assert np.allclose(qml.Hermitian._eigs[key]["eigval"], eigvals, atol=tol, rtol=0)
assert np.allclose(qml.Hermitian._eigs[key]["eigvec"], eigvecs, atol=tol, rtol=0)
assert np.allclose(qubit_unitary[0].params, eigvecs.conj().T, atol=tol, rtol=0)
assert len(qml.Hermitian._eigs) == 1
qubit_unitary = qml.Hermitian(observable, wires=[0]).diagonalizing_gates()
key = tuple(observable.flatten().tolist())
assert np.allclose(qml.Hermitian._eigs[key]["eigval"], eigvals, atol=tol, rtol=0)
assert np.allclose(qml.Hermitian._eigs[key]["eigvec"], eigvecs, atol=tol, rtol=0)
assert np.allclose(qubit_unitary[0].params, eigvecs.conj().T, atol=tol, rtol=0)
assert len(qml.Hermitian._eigs) == 1
@pytest.mark.parametrize("observable, eigvals, eigvecs", EIGVALS_TEST_DATA)
def test_hermitian_diagonalizing_gates_integration(self, observable, eigvals, eigvecs, tol):
"""Tests that the diagonalizing_gates method of the Hermitian class
diagonalizes the given observable."""
tensor_obs = np.kron(observable, observable)
eigvals = np.kron(eigvals, eigvals)
diag_gates = qml.Hermitian(tensor_obs, wires=[0, 1]).diagonalizing_gates()
assert len(diag_gates) == 1
U = diag_gates[0].parameters[0]
x = U @ tensor_obs @ U.conj().T
assert np.allclose(np.diag(np.sort(eigvals)), x, atol=tol, rtol=0)
def test_hermitian_matrix(self, tol):
"""Test that the hermitian matrix method produces the correct output."""
H = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
out = qml.Hermitian(H, wires=0).matrix
# verify output type
assert isinstance(out, np.ndarray)
# verify equivalent to input state
assert np.allclose(out, H, atol=tol, rtol=0)
def test_hermitian_exceptions(self):
"""Tests that the hermitian matrix method raises the proper errors."""
H = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
# test non-square matrix
with pytest.raises(ValueError, match="must be a square matrix"):
qml.Hermitian(H[1:], wires=0).matrix
# test non-Hermitian matrix
H2 = H.copy()
H2[0, 1] = 2
with pytest.raises(ValueError, match="must be Hermitian"):
qml.Hermitian(H2, wires=0).matrix
# Non-parametrized operations and their matrix representation
NON_PARAMETRIZED_OPERATIONS = [
(qml.CNOT, CNOT),
(qml.SWAP, SWAP),
(qml.CZ, CZ),
(qml.S, S),
(qml.T, T),
(qml.CSWAP, CSWAP),
(qml.Toffoli, Toffoli)
]
class TestOperations:
"""Tests for the operations"""
@pytest.mark.parametrize("ops, mat", NON_PARAMETRIZED_OPERATIONS)
def test_matrices(self, ops, mat, tol):
"""Test matrices of non-parametrized operations are correct"""
op = ops(wires=range(ops.num_wires))
res = op.matrix
assert np.allclose(res, mat, atol=tol, rtol=0)
def test_phase_shift(self, tol):
"""Test phase shift is correct"""
# test identity for theta=0
assert np.allclose(qml.PhaseShift._matrix(0), np.identity(2), atol=tol, rtol=0)
assert np.allclose(qml.U1._matrix(0), np.identity(2), atol=tol, rtol=0)
# test arbitrary phase shift
phi = 0.5432
expected = np.array([[1, 0], [0, np.exp(1j * phi)]])
assert np.allclose(qml.PhaseShift._matrix(phi), expected, atol=tol, rtol=0)
assert np.allclose(qml.U1._matrix(phi), expected, atol=tol, rtol=0)
def test_x_rotation(self, tol):
"""Test x rotation is correct"""
# test identity for theta=0
assert np.allclose(qml.RX._matrix(0), np.identity(2), atol=tol, rtol=0)
# test identity for theta=pi/2
expected = np.array([[1, -1j], [-1j, 1]]) / np.sqrt(2)
assert np.allclose(qml.RX._matrix(np.pi / 2), expected, atol=tol, rtol=0)
# test identity for theta=pi
expected = -1j * np.array([[0, 1], [1, 0]])
assert np.allclose(qml.RX._matrix(np.pi), expected, atol=tol, rtol=0)
def test_y_rotation(self, tol):
"""Test y rotation is correct"""
# test identity for theta=0
assert np.allclose(qml.RY._matrix(0), np.identity(2), atol=tol, rtol=0)
# test identity for theta=pi/2
expected = np.array([[1, -1], [1, 1]]) / np.sqrt(2)
assert np.allclose(qml.RY._matrix(np.pi / 2), expected, atol=tol, rtol=0)
# test identity for theta=pi
expected = np.array([[0, -1], [1, 0]])
assert np.allclose(qml.RY._matrix(np.pi), expected, atol=tol, rtol=0)
def test_z_rotation(self, tol):
"""Test z rotation is correct"""
# test identity for theta=0
assert np.allclose(qml.RZ._matrix(0), np.identity(2), atol=tol, rtol=0)
# test identity for theta=pi/2
expected = np.diag(np.exp([-1j * np.pi / 4, 1j * np.pi / 4]))
assert np.allclose(qml.RZ._matrix(np.pi / 2), expected, atol=tol, rtol=0)
# test identity for theta=pi
assert np.allclose(qml.RZ._matrix(np.pi), -1j * Z, atol=tol, rtol=0)
def test_arbitrary_rotation(self, tol):
"""Test arbitrary single qubit rotation is correct"""
# test identity for phi,theta,omega=0
assert np.allclose(qml.Rot._matrix(0, 0, 0), np.identity(2), atol=tol, rtol=0)
# expected result
def arbitrary_rotation(x, y, z):
"""arbitrary single qubit rotation"""
c = np.cos(y / 2)
s = np.sin(y / 2)
return np.array(
[
[np.exp(-0.5j * (x + z)) * c, -np.exp(0.5j * (x - z)) * s],
[np.exp(-0.5j * (x - z)) * s, np.exp(0.5j * (x + z)) * c],
]
)
a, b, c = 0.432, -0.152, 0.9234
assert np.allclose(qml.Rot._matrix(a, b, c), arbitrary_rotation(a, b, c), atol=tol, rtol=0)
def test_C_x_rotation(self, tol):
"""Test controlled x rotation is correct"""
# test identity for theta=0
assert np.allclose(qml.CRX._matrix(0), np.identity(4), atol=tol, rtol=0)
# test identity for theta=pi/2
expected = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1/np.sqrt(2), -1j/np.sqrt(2)], [0, 0, -1j/np.sqrt(2), 1/np.sqrt(2)]])
assert np.allclose(qml.CRX._matrix(np.pi / 2), expected, atol=tol, rtol=0)
# test identity for theta=pi
expected = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, -1j, 0]])
assert np.allclose(qml.CRX._matrix(np.pi), expected, atol=tol, rtol=0)
def test_C_y_rotation(self, tol):
"""Test controlled y rotation is correct"""
# test identity for theta=0
assert np.allclose(qml.CRY._matrix(0), np.identity(4), atol=tol, rtol=0)
# test identity for theta=pi/2
expected = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1/np.sqrt(2), -1/np.sqrt(2)], [0, 0, 1/np.sqrt(2), 1/np.sqrt(2)]])
assert np.allclose(qml.CRY._matrix(np.pi / 2), expected, atol=tol, rtol=0)
# test identity for theta=pi
expected = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1], [0, 0, 1, 0]])
assert np.allclose(qml.CRY._matrix(np.pi), expected, atol=tol, rtol=0)
def test_C_z_rotation(self, tol):
"""Test controlled z rotation is correct"""
# test identity for theta=0
assert np.allclose(qml.CRZ._matrix(0), | np.identity(4) | numpy.identity |
"""
Functions are useful untilities for SITperturb experiments
Notes
-----
Author : <NAME>
Date : 13 August 2017
Usage
-----
[1] calcDecJan(varx,vary,lat,lon,level,levsq)
[2] calcDecJanFeb(varx,vary,lat,lon,level,levsq)
[3] calc_FDR_ttest(varx,vary,alpha_f)
[4] calc_indttest(varx,vary)
[5] calc_weightedAve(var,lats)
[6] calc_spatialCorr(varx,vary,lats,lons,weight)
[7] calc_RMSE(varx,vary,lats,lons,weight)
[8] calc_spatialCorrHeight(varx,vary,lats,lons,weight)
[9] calc_spatialCorrHeightLev(varx,vary,lats,lons,weight,levelq)
[10] detrendData(datavar,years,level,yearmn,yearmx)
[11] detrendDataR(datavar,years,level,yearmn,yearmx)
[12] mk_test(x, alpha)
"""
def calcDecJan(varx,vary,lat,lon,level,levsq):
"""
Function calculates average for December-January
Parameters
----------
varx : 4d array or 5d array
[year,month,lat,lon] or [year,month,lev,lat,lon]
vary : 4d array or 5d array
[year,month,lat,lon] or [year,month,lev,lat,lon]
lat : 1d numpy array
latitudes
lon : 1d numpy array
longitudes
level : string
Height of variable (surface or profile)
levsq : integer
number of levels
Returns
-------
varx_dj : 3d array or 4d array
[year,lat,lon] or [year,lev,lat,lon]
vary_dj : 3d array
[year,lat,lon] or [year,lev,lat,lon]
Usage
-----
varx_dj,vary_dj = calcDecJan(varx,vary,lat,lon,level,levsq)
"""
print('\n>>> Using calcDecJan function!')
### Import modules
import numpy as np
### Reshape for 3d variables
if level == 'surface':
varxravel = np.reshape(varx.copy(),
(int(varx.shape[0]*12),
int(lat.shape[0]),int(lon.shape[0])))
varyravel = np.reshape(vary.copy(),
(int(vary.shape[0]*12),
int(lat.shape[0]),int(lon.shape[0])))
varx_dj = np.empty((varx.shape[0]-1,lat.shape[0],lon.shape[0]))
vary_dj = np.empty((vary.shape[0]-1,lat.shape[0],lon.shape[0]) )
for i in range(0,varxravel.shape[0]-12,12):
counter = 0
if i >= 12:
counter = i//12
djappendh = np.append(varxravel[11+i,:,:],varxravel[12+i,:,:])
djappendf = np.append(varyravel[11+i,:,:],varyravel[12+i,:,:])
varx_dj[counter,:,:] = np.nanmean(np.reshape(djappendh,
(2,int(lat.shape[0]),int(lon.shape[0]))),
axis=0)
vary_dj[counter,:,:] = np.nanmean(np.reshape(djappendf,
(2,int(lat.shape[0]),int(lon.shape[0]))),
axis=0)
### Reshape for 4d variables
elif level == 'profile':
varxravel = np.reshape(varx.copy(),
(int(varx.shape[0]*12.),levsq,
int(lat.shape[0]),int(lon.shape[0])))
varyravel = np.reshape(vary.copy(),
(int(vary.shape[0]*12.),levsq,
int(lat.shape[0]),int(lon.shape[0])))
varx_dj = np.empty((int(varx.shape[0]-1),levsq,
int(lat.shape[0]),int(lon.shape[0])))
vary_dj = np.empty((int(vary.shape[0]-1),levsq,
int(lat.shape[0]),int(lon.shape[0])) )
for i in range(0,varxravel.shape[0]-12,12):
counter = 0
if i >= 12:
counter = i//12
djappendh = np.append(varxravel[11+i,:,:,:],
varxravel[12+i,:,:,:])
djappendf = np.append(varyravel[11+i,:,:,:],
varyravel[12+i,:,:,:])
varx_dj[counter,:,:] = np.nanmean(np.reshape(djappendh,
(2,levsq,int(lat.shape[0]),
int(lon.shape[0]))),axis=0)
vary_dj[counter,:,:] = np.nanmean(np.reshape(djappendf,
(2,levsq,int(lat.shape[0]),
int(lon.shape[0]))),axis=0)
else:
print(ValueError('Selected wrong height - (surface or profile!)!'))
print('Completed: Organized data by months (ON,DJ,FM)!')
print('*Completed: Finished calcDecJan function!')
return varx_dj,vary_dj
###############################################################################
###############################################################################
###############################################################################
def calcDecJanFeb(varx,vary,lat,lon,level,levsq):
"""
Function calculates average for December-January-February
Parameters
----------
varx : 4d array or 5d array
[year,month,lat,lon] or [year,month,lev,lat,lon]
vary : 4d array or 5d array
[year,month,lat,lon] or [year,month,lev,lat,lon]
lat : 1d numpy array
latitudes
lon : 1d numpy array
longitudes
level : string
Height of variable (surface or profile)
levsq : integer
number of levels
Returns
-------
varx_djf : 3d array or 4d array
[year,lat,lon] or [year,lev,lat,lon]
vary_djf : 3d array
[year,lat,lon] or [year,lev,lat,lon]
Usage
-----
varx_djf = calcDecJanFeb(varx,vary,lat,lon,level,levsq)
"""
print('\n>>> Using calcDecJanFeb function!')
### Import modules
import numpy as np
### Reshape for 3d variables
if level == 'surface':
varxravel = np.reshape(varx.copy(),
(int(varx.shape[0]*12),
int(lat.shape[0]),int(lon.shape[0])))
varyravel = np.reshape(vary.copy(),
(int(vary.shape[0]*12),
int(lat.shape[0]),int(lon.shape[0])))
varx_djf = np.empty((varx.shape[0]-1,lat.shape[0],lon.shape[0]))
vary_djf = np.empty((vary.shape[0]-1,lat.shape[0],lon.shape[0]) )
for i in range(0,varxravel.shape[0]-12,12):
counter = 0
if i >= 12:
counter = i//12
djfappendh1 = np.append(varxravel[11+i,:,:],varxravel[12+i,:,:])
djfappendf1 = np.append(varyravel[11+i,:,:],varyravel[12+i,:,:])
djfappendh = np.append(djfappendh1,varxravel[13+i,:,:])
djfappendf = np.append(djfappendf1,varyravel[13+i,:,:])
varx_djf[counter,:,:] = np.nanmean(np.reshape(djfappendh,
(3,int(lat.shape[0]),int(lon.shape[0]))),
axis=0)
vary_djf[counter,:,:] = np.nanmean(np.reshape(djfappendf,
(3,int(lat.shape[0]),int(lon.shape[0]))),
axis=0)
### Reshape for 4d variables
elif level == 'profile':
varxravel = np.reshape(varx.copy(),
(int(varx.shape[0]*12.),levsq,
int(lat.shape[0]),int(lon.shape[0])))
varyravel = np.reshape(vary.copy(),
(int(vary.shape[0]*12.),levsq,
int(lat.shape[0]),int(lon.shape[0])))
varx_djf = np.empty((int(varx.shape[0]-1),levsq,
int(lat.shape[0]),int(lon.shape[0])))
vary_djf = np.empty((int(vary.shape[0]-1),levsq,
int(lat.shape[0]),int(lon.shape[0])) )
for i in range(0,varxravel.shape[0]-12,12):
counter = 0
if i >= 12:
counter = i//12
djfappendh1 = np.append(varxravel[11+i,:,:,:],
varxravel[12+i,:,:,:])
djfappendf1 = np.append(varyravel[11+i,:,:,:],
varyravel[12+i,:,:,:])
djfappendh = np.append(djfappendh1,
varxravel[13+i,:,:,:])
djfappendf = np.append(djfappendf1,
varyravel[13+i,:,:,:])
varx_djf[counter,:,:] = np.nanmean(np.reshape(djfappendh,
(3,levsq,int(lat.shape[0]),
int(lon.shape[0]))),axis=0)
vary_djf[counter,:,:] = np.nanmean(np.reshape(djfappendf,
(3,levsq,int(lat.shape[0]),
int(lon.shape[0]))),axis=0)
else:
print(ValueError('Selected wrong height - (surface or profile!)!'))
print('Completed: Organized data by months (DJF)!')
print('*Completed: Finished calcDecJanFeb function!')
return varx_djf
###############################################################################
###############################################################################
###############################################################################
def calc_FDR_ttest(varx,vary,alpha_f):
"""
Function first calculates statistical difference for 2 independent
sample t-test and then adjusts using a false discovery rate (FDR)
where alpha_o = alpha_FDR
Parameters
----------
varx : 2d or 3d array
vary : 2d or 3d array
alpha_f : float (alpha_o = alpha_FDR)
Returns
-------
pruns : 1d or 2d array of adjusted p values
Usage
-----
calc_FDR_ttest(varx,vary,alpha_f)
"""
print('\n>>> Using calc_FDR_ttest function!')
### Import modules
import numpy as np
import scipy.stats as sts
import statsmodels.stats.multitest as fdr
### 2-independent sample t-test
stat,pvalue = sts.ttest_ind(varx,vary,nan_policy='omit')
### Ravel all 2d pvalues
if pvalue.ndim == 2:
pvalall = | np.reshape(pvalue,(pvalue.shape[0]* pvalue.shape[1])) | numpy.reshape |
"""
Copyright (c) 2018 Intel Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import numpy as np
from mo.front.mxnet.extractors.utils import get_mxnet_layer_attrs
from mo.front.extractor import FrontExtractorOp
from mo.ops.op import Op
class ProposalFrontExtractor(FrontExtractorOp):
op = '_contrib_Proposal'
enabled = True
@staticmethod
def extract(node):
attrs = get_mxnet_layer_attrs(node.symbol_dict)
pre_nms_topn = attrs.int('rpn_pre_nms_top_n', 6000)
post_nms_topn = attrs.int('rpn_post_nms_top_n', 300)
nms_thresh = attrs.float('threshold', 0.7)
min_size = attrs.int('rpn_min_size', 16)
scale = attrs.tuple("scales", float, (4, 8, 16, 32))
ratio = attrs.tuple("ratios", float, (0.5, 1, 2))
feat_stride = attrs.int('feature_stride', 16)
update_attrs = {
'feat_stride': feat_stride,
'ratio': np.array(ratio),
'min_size': min_size,
'scale': | np.array(scale) | numpy.array |
"""This module simulates trajectories of interacting particles in 3D space.\n
Particles are called "Walkers", in reference to the fact at each iteration each
particle is "walking" towards or away from others. Various mathematical
interaction laws and relationship generation rules are provided, yielding very
different simulation results.
"""
from collections import namedtuple
from dataclasses import dataclass
from operator import attrgetter
from time import perf_counter_ns
import numpy as np
import numpy.linalg as la
from numpy.random import default_rng
from dynasty.utils import LabeledEnum
def rand_spread_array(shape, avg=0, var=1, rng=None):
"""Generate a ndarray with given shape populated with random float
values in the range ]avg-var, avg+var[.
"""
rng = rng or default_rng()
return var * (2*rng.random(shape) - 1) + avg
def repeat_newaxis(array, n):
"""Repeat the given `array` `n` times along a new outer axis."""
return np.repeat(array[None, ...], n, axis=0)
def diff_array(array):
"""Returns a square matrix of all differences of an array's elements.\n
This function supports arbitrary shapes (for exemple, (n, 3) if the input
array represents multiple points in 3D space).
Example: diff_array([a, b, c]) ->
a-a b-a c-a
a-b b-b c-b
a-c b-c c-c
"""
tiled = repeat_newaxis(array, array.shape[0])
# Swap the two first axis (this is equivalent to transposition when input
# array has one dimention), and return the element-wie difference
return tiled - tiled.swapaxes(0, 1)
class InterLaw(LabeledEnum):
"""Enumeration of interaction laws.\n
Impacts the mathematical formula binding walkers together.
"""
POSITION = 0, "Distance fraction"
VELOCITY = 1, "Velocity"
NEWTON_LINEAR = 2, "Newton's (linear variant)"
NEWTON = 3, "Newton's (quadratic)"
ASYMMETRY = 4, "Asymmetry"
class RelModel(LabeledEnum):
"""Enumeration of relation models.\n
Impacts relation mask generation.
"""
ONE_TO_ONE = 0, "One to one"
SPARSE = 1, "Sparse (25%)"
MANY_TO_MANY = 2, "Many to many"
class SeedableRNG:
"""Class that wraps a NumPy pseudo-random `Generator`, and provide utility
methods to restart or reseed it.
"""
def __init__(self, seed=None):
self.seed = seed
self.generator = default_rng(seed)
def reseed(self, seed=None):
"""Reseed the PRNG.\n
If no `seed` argument is given, the last seed will be used, hence the
PRNG will generate the same sequence of numbers again.
"""
if seed is not None:
self.seed = seed
self.generator = default_rng(self.seed)
@dataclass
class SystemParameters:
count: int = 3
spread: float = 10
inter_law: InterLaw = InterLaw.POSITION
rel_model: RelModel = RelModel.ONE_TO_ONE
rel_avg: float = .1
rel_var: float = 0
rel_sym: bool = False
iterations: int = 10
SystemRNGs = namedtuple('RNGs', ('start_pos', 'rel_mask', 'rel_matrix'))
class WalkerSystem:
def __init__(self, params=SystemParameters()):
self.params = params
# Use perf_counter_ns for seeding, because time_ns precision is very
# poor on some systems - Windows, not to name it
self.rngs = SystemRNGs(
*(SeedableRNG(perf_counter_ns() + i) for i in range(3))
)
# Those will be populated later by various computing methods
self.rel_mask, self.rel_matrix = None, None
self.start_pos, self.positions = None, None
def generate_start_pos(self):
rng = self.rngs.start_pos
rng.reseed()
# Start pos in ]-1, 1[
self.start_pos = rand_spread_array(
(self.params.count, 3), rng=rng.generator
)
def generate_relation_mask(self):
n, model = attrgetter('count', 'rel_model')(self.params)
rng = self.rngs.rel_mask
rng.reseed()
if model == RelModel.ONE_TO_ONE:
# One walker is in relation with another
self.rel_mask = np.roll( | np.eye(n, dtype=bool) | numpy.eye |
import numpy as np
from scipy.linalg import blas
from .fourier_transform import FourierTransform, multiplex_for_tensor_fields, _get_float_and_complex_dtype
from ..field import Field
from ..config import Configuration
import numexpr as ne
class MatrixFourierTransform(FourierTransform):
'''A Matrix Fourier Transform (MFT) object.
This Fourier transform is based on the MFT described in [Soummer2007]_. It requires both
the input and output grid to be separated in Cartesian coordinates. Additionally, due to
current implementation limitations, this Fourier transform only supports one- and two-dimensional
grids.
.. [Soummer2007] Soummer et al. 2007, "Fast computation of Lyot-style
coronagraph propagation".
Parameters
----------
input_grid : Grid
The grid that is expected for the input field.
output_grid : Grid
The grid that is produced by the Fourier transform.
precompute_matrices : boolean or None
Whether to precompute the matrices used in the MFT. Turning this on will provide a 20-30%
speedup, in exchange for higher memory usage.If this is False, the matrices will be
calculated each time a Fourier transform is performed. If this is True, the matrices will be
calculated once, and reused for future evaluations. If this is None, the choice will be
determined by the configuration file.
allocate_intermediate : boolean or None
Whether to reserve memory for the intermediate result for the MFT. This provides a 5-10%
speedup in exchange for higher memory usage. If this is None, the choice will be determined
by the configuration file.
Raises
------
ValueError
If the input grid is not separated in Cartesian coordinates, if it's not one- or two-
dimensional, or if the output grid has a different dimension than the input grid.
'''
def __init__(self, input_grid, output_grid, precompute_matrices=None, allocate_intermediate=None):
# Check input grid assumptions
if not input_grid.is_separated or not input_grid.is_('cartesian'):
raise ValueError('The input_grid must be separable in cartesian coordinates.')
if not output_grid.is_separated or not output_grid.is_('cartesian'):
raise ValueError('The output_grid must be separable in cartesian coordinates.')
if input_grid.ndim not in [1, 2]:
raise ValueError('The input_grid must be one- or two-dimensional.')
if input_grid.ndim != output_grid.ndim:
raise ValueError('The input_grid must have the same dimensions as the output_grid.')
self.input_grid = input_grid
self.output_grid = output_grid
self.shape_input = input_grid.shape
self.shape_output = output_grid.shape
self.ndim = input_grid.ndim
# Get the value from the configuration file if left at default.
if precompute_matrices is None:
precompute_matrices = Configuration().fourier.mft.precompute_matrices
self.precompute_matrices = precompute_matrices
# Get the value from the configuration file if left at default.
if allocate_intermediate is None:
allocate_intermediate = Configuration().fourier.mft.allocate_intermediate
self.allocate_intermediate = allocate_intermediate
self.matrices_dtype = None
self.intermediate_dtype = None
self._remove_matrices()
def _compute_matrices(self, dtype):
'''Compute the matrices for the MFT using the specified data type.
Parameters
---
dtype : numpy data type
The data type for which to calculate the matrices.
'''
# Set the correct complex and real data type, based on the input data type.
float_dtype, complex_dtype = _get_float_and_complex_dtype(dtype)
# Check if the matrices need to be (re)calculated.
if self.matrices_dtype != complex_dtype:
self.weights_input = (self.input_grid.weights).astype(float_dtype, copy=False)
self.weights_output = (self.output_grid.weights / (2 * np.pi)**self.ndim).astype(float_dtype, copy=False)
# If all input weights are all the same, use a scalar instead.
if not np.isscalar(self.weights_input) and np.all(self.weights_input == self.weights_input[0]):
self.weights_input = self.weights_input[0]
# If all output weights are all the same, use a scalar instead.
if not np.isscalar(self.weights_output) and np.all(self.weights_output == self.weights_output[0]):
self.weights_output = self.weights_output[0]
if self.ndim == 1:
xu = np.outer(self.output_grid.x, self.input_grid.x)
self.M = ne.evaluate('exp(-1j * xu)').astype(complex_dtype, copy=False)
elif self.ndim == 2:
x, y = self.input_grid.coords.separated_coords
u, v = self.output_grid.coords.separated_coords
vy = np.outer(v, y)
xu = np.outer(x, u)
self.M1 = ne.evaluate('exp(-1j * vy)').astype(complex_dtype, copy=False)
self.M2 = ne.evaluate('exp(-1j * xu)').astype(complex_dtype, copy=False)
self.matrices_dtype = complex_dtype
# Checki if the intermediate array needs to be (re)allocated.
if self.intermediate_dtype != complex_dtype:
if self.ndim == 2:
self.intermediate_array = np.empty((self.input_grid.shape[0], self.M2.shape[1]), dtype=complex_dtype)
self.intermediate_dtype = complex_dtype
def _remove_matrices(self):
'''Remove the matrices after a Fourier transform.
This is is used to clean up the used matrices after a Fourier transform operation.
'''
if not self.precompute_matrices:
if self.ndim == 1:
self.M = None
elif self.ndim == 2:
self.M1 = None
self.M2 = None
self.matrices_dtype = None
if not self.allocate_intermediate:
if self.ndim == 2:
self.intermediate_array = None
self.intermediate_dtype = None
@multiplex_for_tensor_fields
def forward(self, field):
'''Returns the forward Fourier transform of the :class:`Field` field.
Parameters
----------
field : Field
The field to Fourier transform.
Returns
--------
Field
The Fourier transform of the field.
'''
self._compute_matrices(field.dtype)
field = field.astype(self.matrices_dtype, copy=False)
if self.ndim == 1:
f = field * self.weights_input
res = | np.dot(self.M, f) | numpy.dot |
import numpy as np
from io import BytesIO
import os
import re
import tempfile
import warnings
import xml.parsers.expat
import pytest
import matplotlib as mpl
from matplotlib import dviread
from matplotlib.figure import Figure
import matplotlib.pyplot as plt
from matplotlib.testing.decorators import image_comparison
with warnings.catch_warnings():
warnings.simplefilter('ignore')
needs_usetex = pytest.mark.skipif(
not mpl.checkdep_usetex(True),
reason="This test needs a TeX installation")
def test_visibility():
fig, ax = plt.subplots()
x = np.linspace(0, 4 * np.pi, 50)
y = np.sin(x)
yerr = np.ones_like(y)
a, b, c = ax.errorbar(x, y, yerr=yerr, fmt='ko')
for artist in b:
artist.set_visible(False)
fd = BytesIO()
fig.savefig(fd, format='svg')
fd.seek(0)
buf = fd.read()
fd.close()
parser = xml.parsers.expat.ParserCreate()
parser.Parse(buf) # this will raise ExpatError if the svg is invalid
@image_comparison(baseline_images=['fill_black_with_alpha'], remove_text=True,
extensions=['svg'])
def test_fill_black_with_alpha():
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.scatter(x=[0, 0.1, 1], y=[0, 0, 0], c='k', alpha=0.1, s=10000)
@image_comparison(baseline_images=['noscale'], remove_text=True)
def test_noscale():
X, Y = np.meshgrid(np.arange(-5, 5, 1), np.arange(-5, 5, 1))
Z = | np.sin(Y ** 2) | numpy.sin |
import batoid
import numpy as np
from test_helpers import timer, init_gpu, rays_allclose, checkAngle, do_pickle
@timer
def test_properties():
rng = np.random.default_rng(5)
size = 10
for i in range(100):
x = rng.normal(size=size)
y = rng.normal(size=size)
z = rng.normal(size=size)
vx = rng.normal(size=size)
vy = rng.normal(size=size)
vz = rng.normal(size=size)
t = rng.normal(size=size)
w = rng.normal(size=size)
fx = rng.normal(size=size)
vig = rng.choice([True, False], size=size)
fa = rng.choice([True, False], size=size)
cs = batoid.CoordSys(
origin=rng.normal(size=3),
rot=batoid.RotX(rng.normal())@batoid.RotY(rng.normal())
)
rv = batoid.RayVector(x, y, z, vx, vy, vz, t, w, fx, vig, fa, cs)
np.testing.assert_array_equal(rv.x, x)
np.testing.assert_array_equal(rv.y, y)
np.testing.assert_array_equal(rv.z, z)
np.testing.assert_array_equal(rv.r[:, 0], x)
np.testing.assert_array_equal(rv.r[:, 1], y)
np.testing.assert_array_equal(rv.r[:, 2], z)
np.testing.assert_array_equal(rv.vx, vx)
np.testing.assert_array_equal(rv.vy, vy)
np.testing.assert_array_equal(rv.vz, vz)
np.testing.assert_array_equal(rv.v[:, 0], vx)
np.testing.assert_array_equal(rv.v[:, 1], vy)
np.testing.assert_array_equal(rv.v[:, 2], vz)
np.testing.assert_array_equal(rv.k[:, 0], rv.kx)
np.testing.assert_array_equal(rv.k[:, 1], rv.ky)
np.testing.assert_array_equal(rv.k[:, 2], rv.kz)
np.testing.assert_array_equal(rv.t, t)
np.testing.assert_array_equal(rv.wavelength, w)
np.testing.assert_array_equal(rv.flux, fx)
np.testing.assert_array_equal(rv.vignetted, vig)
np.testing.assert_array_equal(rv.failed, fa)
assert rv.coordSys == cs
rv._syncToDevice()
do_pickle(rv)
@timer
def test_positionAtTime():
rng = np.random.default_rng(57)
size = 10_000
x = rng.uniform(-1, 1, size=size)
y = rng.uniform(-1, 1, size=size)
z = rng.uniform(-0.1, 0.1, size=size)
vx = rng.uniform(-0.05, 0.05, size=size)
vy = rng.uniform(-0.05, 0.05, size=size)
vz = np.sqrt(1.0 - vx*vx - vy*vy)
# Try with default t=0 first
rv = batoid.RayVector(x, y, z, vx, vy, vz)
np.testing.assert_equal(rv.x, x)
np.testing.assert_equal(rv.y, y)
np.testing.assert_equal(rv.z, z)
np.testing.assert_equal(rv.vx, vx)
np.testing.assert_equal(rv.vy, vy)
np.testing.assert_equal(rv.vz, vz)
np.testing.assert_equal(rv.t, 0.0)
np.testing.assert_equal(rv.wavelength, 0.0)
for t1 in [0.0, 1.0, -1.1, 2.5]:
np.testing.assert_equal(
rv.positionAtTime(t1),
rv.r + t1 * rv.v
)
# Now add some random t's
t = rng.uniform(-1.0, 1.0, size=size)
rv = batoid.RayVector(x, y, z, vx, vy, vz, t)
np.testing.assert_equal(rv.x, x)
np.testing.assert_equal(rv.y, y)
np.testing.assert_equal(rv.z, z)
np.testing.assert_equal(rv.vx, vx)
np.testing.assert_equal(rv.vy, vy)
np.testing.assert_equal(rv.vz, vz)
np.testing.assert_equal(rv.t, t)
np.testing.assert_equal(rv.wavelength, 0.0)
for t1 in [0.0, 1.4, -1.3, 2.1]:
np.testing.assert_equal(
rv.positionAtTime(t1),
rv.r + rv.v*(t1-rv.t)[:,None]
)
@timer
def test_propagate():
rng = np.random.default_rng(577)
size = 10_000
x = rng.uniform(-1, 1, size=size)
y = rng.uniform(-1, 1, size=size)
z = rng.uniform(-0.1, 0.1, size=size)
vx = rng.uniform(-0.05, 0.05, size=size)
vy = rng.uniform(-0.05, 0.05, size=size)
vz = np.sqrt(1.0 - vx*vx - vy*vy)
# Try with default t=0 first
rv = batoid.RayVector(x, y, z, vx, vy, vz)
for t1 in [0.0, 1.0, -1.1, 2.5]:
rvcopy = rv.copy()
r1 = rv.positionAtTime(t1)
rvcopy.propagate(t1)
np.testing.assert_equal(
rvcopy.r,
r1
)
np.testing.assert_equal(
rvcopy.v,
rv.v
)
np.testing.assert_equal(
rvcopy.t,
t1
)
# Now add some random t's
t = rng.uniform(-1.0, 1.0, size=size)
rv = batoid.RayVector(x, y, z, vx, vy, vz, t)
for t1 in [0.0, 1.0, -1.1, 2.5]:
rvcopy = rv.copy()
r1 = rv.positionAtTime(t1)
rvcopy.propagate(t1)
np.testing.assert_equal(
rvcopy.r,
r1
)
np.testing.assert_equal(
rvcopy.v,
rv.v
)
np.testing.assert_equal(
rvcopy.t,
t1
)
@timer
def test_phase():
rng = np.random.default_rng(5772)
size = 10_000
for n in [1.0, 1.3]:
x = rng.uniform(-1, 1, size=size)
y = rng.uniform(-1, 1, size=size)
z = rng.uniform(-0.1, 0.1, size=size)
vx = rng.uniform(-0.05, 0.05, size=size)
vy = rng.uniform(-0.05, 0.05, size=size)
vz = np.sqrt(1.0/(n*n) - vx*vx - vy*vy)
t = rng.uniform(-1.0, 1.0, size=size)
wavelength = rng.uniform(300e-9, 1100e-9, size=size)
rv = batoid.RayVector(x, y, z, vx, vy, vz, t, wavelength)
# First explicitly check that phase is 0 at position and time of individual
# rays
for i in rng.choice(size, size=10):
np.testing.assert_equal(
rv.phase(rv.r[i], rv.t[i])[i],
0.0
)
# Now use actual formula
# phi = k.(r-r0) - (t-t0)omega
# k = 2 pi v / lambda |v|^2
# omega = 2 pi / lambda
# |v| = 1 / n
for r1, t1 in [
((0, 0, 0), 0),
((0, 1, 2), 3),
((-1, 2, 4), -1),
((0, 1, -4), -2)
]:
phi = np.einsum("ij,ij->i", rv.v, r1-rv.r)
phi *= n*n
phi -= (t1-rv.t)
phi *= 2*np.pi/wavelength
np.testing.assert_allclose(
rv.phase(r1, t1),
phi,
rtol=0,
atol=1e-7
)
for i in rng.choice(size, size=10):
s = slice(i, i+1)
rvi = batoid.RayVector(
x[s], y[s], z[s],
vx[s], vy[s], vz[s],
t[s].copy(), wavelength[s].copy()
)
# Move integer number of wavelengths ahead
ti = rvi.t[0]
wi = rvi.wavelength[0]
r1 = rvi.positionAtTime(ti + 5123456789*wi)[0]
a = rvi.amplitude(r1, ti)
np.testing.assert_allclose(a.real, 1.0, rtol=0, atol=2e-5)
np.testing.assert_allclose(a.imag, 0.0, rtol=0, atol=2e-5)
# Half wavelength
r1 = rvi.positionAtTime(ti + 6987654321.5*wi)[0]
a = rvi.amplitude(r1, ti)
np.testing.assert_allclose(a.real, -1.0, rtol=0, atol=2e-5)
np.testing.assert_allclose(a.imag, 0.0, rtol=0, atol=2e-5)
# Quarter wavelength
r1 = rvi.positionAtTime(ti + 0.25*wi)[0]
a = rvi.amplitude(r1, ti)
np.testing.assert_allclose(a.real, 0.0, rtol=0, atol=2e-5)
np.testing.assert_allclose(a.imag, 1.0, rtol=0, atol=2e-5)
# Three-quarters wavelength
r1 = rvi.positionAtTime(ti + 7182738495.75*wi)[0]
a = rvi.amplitude(r1, ti)
| np.testing.assert_allclose(a.real, 0.0, rtol=0, atol=2e-5) | numpy.testing.assert_allclose |
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.cm import get_cmap
from pandas import DataFrame
from scipy.interpolate import griddata
import glob
import os
#Package Imports
from .read import load_mol_abund,\
load_rates, get_reac_str, total_rates,\
load_radfield,\
read_levels,read_trans
from .misc import contour_points, get_contour_arr, remove_nan, sigfig, iterable, nint
from . import __path__ as pkg_path
#Functions for setting and getting global directory path
# where chemical code is located, base_dir
def set_base_dir(direc):
if direc[-1]!='/':
direc = direc+'/'
fpath = pkg_path[0]+'/pkg_files/base_dir.txt'
f = open(fpath,'w')
f.write(direc)
f.close()
def get_base_dir():
fpath = pkg_path[0]+'/pkg_files/base_dir.txt'
try:
f = open(fpath)
direc = f.read()
f.close()
assert os.path.exists(direc)
except (OSError, AssertionError) as e:
direc = pkg_path[0]+'/test_files/'
return direc
#Some constants that get used throughout.
mp = 1.67e-24 #Mass of proton in g
mau = 1.496e11 #Conversion from AU to meters.
class chem_mod:
'''
A class to handle loading, viewing, and manipulating output from
the disk chemical modeling code presented in Fogel et al. 2011.
For more in-depth documentation, visit
https://github.com/richardseifert/Chemvene
To create an instance, the following three paths must be provided.
outdir - string path to the runs/ directory where model output is
stored.
environ - string path to the environ/ directory used to run your
chemical model. (Must given it outdir/environ doesn't exist)
inp - string filename of the input file used to run your model.
(Must be given if outdir/0io* doesn't exits)
'''
################################################################################
################################ Initialization ################################
################################################################################
def __init__(self,outdir,environ=None,inp=None,base_dir=None):
self.outdir = outdir
if self.outdir[-1] != '/':
self.outdir += '/'
if base_dir is None:
self.bsd = get_base_dir()
else:
self.bsd = base_dir
if not environ is None:
self.set_environ(environ)
elif os.path.exists(self.outdir+'environ/'):
self.set_environ(self.outdir+'environ/')
else:
raise FileNotFoundError("Could not determine environ/ directory to use for this model.")
if not inp is None:
self.set_environ(environ)
else:
outdir_0io_paths = glob.glob(self.outdir+'0io*')
if len(outdir_0io_paths) > 0:
self.set_inp(outdir_0io_paths[0].split('/')[-1])
else:
raise FileNotFoundError("Could not determine 0io file to use for this model.")
self.phys = DataFrame()
self.radfields = {}
self.abunds = {}
self.rates = {}
self.load_physical()
self.load_times()
def set_environ(self,environ):
self.environ = environ
if self.environ[-1] != '/':
self.environ += '/'
def set_inp(self,inp):
self.inp = self.environ+inp
inp_types = ['spec','reac','uv','xray','isrf','rn']
self.inp_paths = {k:None for k in inp_types}
d = np.genfromtxt(self.inp,dtype=str)
for i,k in enumerate(inp_types):
if os.path.exists(self.bsd+d[i]):
self.inp_paths[k] = self.bsd+d[i]
def copy(self):
'''
Make a hard copy of a chem_mod instance.
'''
#Initialize
new_inst = chem_mod(outdir=self.outdir,environ=self.environ,inp=self.inp)
#Hard copy physical quantities
new_inst.phys = self.phys.copy()
#for q in self.phys.columns:
# new_inst.set_quant(q,self.phys[q])
#Hard copy abundances
for mol in self.abunds.keys():
new_inst.abunds[mol] = self.abunds[mol].copy()
#Hard copy rates
for rid in self.rates.keys():
new_inst.rates[rid] = self.rates[rid].copy()
return new_inst
################################################################################
############################### General Loading ################################
################################################################################
def merge(self,tbl):
'''
Prepare a given table to be merged according to position, R and zAU.
ARGUMENTS:
tbl - A pandas table containing the two columns 'R' and either 'shell' or 'zAU'.
RETURNS:
merged - A tbl with the same number of rows as phys. The returned table
has values ordered according to phys['R'] and phys['shell']
'''
#Match R values to their nearest R values in phys['R'].
#This is necessary for the relational merge to work.
phys_R = np.array(list(set(self.phys['R'])))
diffs = np.vstack([(pr-tbl['R'])**2 for pr in phys_R])
inds = np.argmin(diffs,axis=0)
tbl['R'] = phys_R[inds]
#Merge according to columns of phys.
if 'shell' in tbl.columns:
merged = self.phys.merge(tbl,'left',on=['R','shell'])
elif 'zAU' in tbl.columns:
#Match by nearest R and zAU.
# pandas.DataFrame.merge has failed me in this reguard.. :(
# So I just had to do it myself, huney, using griddata.
merge_cols = [col for col in tbl.columns if not col in self.phys.columns]
points = np.vstack([tbl['R'],tbl['zAU']]).T
values = np.array(tbl[merge_cols])
phys_points = np.array([self.phys['R'],self.phys['zAU']]).T
matched = griddata(points,values,phys_points,method='nearest')
merged = self.phys.copy()
for i,col in enumerate(merge_cols):
merged[col] = matched[:,i]
return merged
def set_times(self,tbl):
'''
Method that takes a table with times as column headers and changes the headers
to match the nearest model timesteps.
ARGUMENTS:
tbl - A pandas.DataFrame object with times (in years) as columns header.
RETURNS:
The same table, but times have been corrected to the nearest model times.
'''
ctimes = tbl.columns
mtimes = self.nearest_times(ctimes,itr=True)
return tbl.rename(columns=dict(zip(ctimes,mtimes)))
################################################################################
############################# Handling Timesteps ###############################
################################################################################
def load_times(self):
'''
Method that reads the 2times.inp file for the model and produces an array of
the time at each model timestep.
No arguments or returns; times are stored in self.times variable.
'''
f = open(self.outdir+'2times.inp')
f.readline()
t_end = float(f.readline().split()[0].replace('D','E'))
t_start = float(f.readline().split()[0].replace('D','E'))
nsteps = int(f.readline().split()[0])
self.times = sigfig(np.logspace(np.log10(t_start),np.log10(t_end),nsteps), 4)
def nearest_times(self,times,itr=False):
'''
Function for finding nearest timesteps to a given time or list of times.
ARGUMENTS:
times - Time or list of times. Must be values that can be cast to floats.
itr - Boolean whether or not to return a scalar if possible. Default False.
If a single time is given, itr=False will return a scalar value.
itr=True will return a list of length one.
'''
#If None was given, do nothing. Return None.
if times is None:
return times
#Otherwise, check if time is iterable. If it's not, make it a single-valued array.
try:
iter(times)
times = np.array(times).astype(float)
except TypeError:
times = np.asarray([times]).astype(float)
#Find the nearest times in self.times.
nearest = self.times[ np.argmin([ (self.times - t)**2 for t in times ], axis=1) ]
#Depending on the number of times given, return an array or a scalar.
if len(nearest) == 1 and not itr:
return nearest[0]
else:
return nearest
def nearest_time_i(self,time):
return np.argmin( (self.times - time)**2 )
################################################################################
######################## Read/Write Model Quantities ###########################
################################################################################
def load_physical(self):
'''
Method that loads the disk physical model from 1environ files.
'''
env_paths = glob.glob(self.environ+'1environ*')
#Determine number of shells in model.
f1 = open(env_paths[0])
for i,line in enumerate(f1):
if i==2:
nshells = int(line.strip())
f1.close()
break
dat = np.array([])
shells = np.array([np.arange(nshells)+1]).T
for path in env_paths:
d = np.loadtxt(path,skiprows=3)
d = np.hstack([d,shells])
if len(dat) != 0:
dat = np.vstack([dat,d])
else:
dat = d
#Get header from test file.
f = open(env_paths[0])
header = f.readline()
f.close()
for i,k in enumerate(header.split()+['shell']):
self.phys[k] = dat[:,i]
def load_field(self,field,path=None):
if path is None:
path = self.inp_paths[field]
print("Loading %s field from: %s"%(field,path))
dat = load_radfield(path)
R = dat[:,0]
zAU = dat[:,1]
spec = dat[:,2]
flux = dat[:,3]
self.radfields[field] = DataFrame()
spec_vals = | np.unique(spec) | numpy.unique |
from __future__ import print_function
import numpy as np
import pandas as pd
import inspect
import os
import time
from . import Model
from . import Utils as U
#------------------------------
#FINDING NEAREST NEIGHBOR
#------------------------------
def mindistance(x,xma,Nx):
distx = 0
mindist = 1000000 * U.PC * U.AU
j = None
for i in range(Nx):
distx = abs(x-xma[i])
if (distx<mindist):
mindist=distx
j=i
return j
#------------------------------
#OVERLAPING SUBMODELS INTO GRID
#------------------------------
def overlap(GRID, submodels = [''], folder = './Subgrids/',
T_min = 30., rho_min = 1.e9,
all = False, radmc3d = False):
func_name = inspect.stack()[0][3]
if folder[-1] != '/': folder = folder + '/'
t0 = time.time()
num=int(np.loadtxt(os.popen("ls -1 %s*.dat| wc -l"%folder)))
data=os.popen("ls -1 %s*.dat"%folder).read().split('\n',num)[:-1]
if all:
names = [name for name in data] # if '_S.' in name or '_MSW' in name]
files = [ | np.loadtxt(name) | numpy.loadtxt |
# Calculates the LMC example in LVM_Coordinates.doc
#
import numpy as np
import LVMutils as LVMu # Contains utility routines
np.set_printoptions(precision=3,suppress=True) # Minimize on-screen digits
#---------------- MAIN ROUTINE STARTS HERE -------------------------
r2d = 180.0 / np.pi # Converts radians to degrees
r360 = 2 * np.pi # 360 deg in radians (2pi)
r180 = np.pi # 180 deg in radians
r90 = np.pi / 2 # 90 deg in radians
latD = LVMu.latD # Latitude of Las Campanas in degrees
raD = (5.0 + 23.0/60 + 34.5/3600) / 24.0 * 360.0 # RA of LMC (05h 23m 34.5s) in degrees
decD = -1.0*(69.0 + 45.0/60 + 22.0/3600) # dec of LMC (-69 45 22) in degrees
haD = -1.0 / 24 * 360 # HA of LMC in degrees one hour before transit
print ("lat = ",latD)
print ("RA = ",raD)
print ("Dec = ",decD)
print ("HA = ",haD)
print ("")
#---- Calculate Azimuth and Elevation (Section 4.1 of doc)
azD,elD = LVMu.RAdec2AzEl(raD,decD,raD+haD) # Calculate Az and El (degrees) of target 1 hr before transit
print ("Az = ",azD)
print ("El = ",elD)
print ("")
#---- Calculate the SEl and SAz siderostat angles (Section 4.3 of doc)
sazD,selD = LVMu.AzEl2SazSel(azD,elD) # Calculate siderostat angles
print ("SAz = ",sazD)
print ("SEl = ",selD)
print ("")
#---- Generate the base mirror matrices for the SAz and SEl mirrors - See Doc
nx,ny,nz = -1.0/np.sqrt(2.0) , +1.0/np.sqrt(2.0) , 0.0 # Normal unit vector to SAz mirror
mSAz = LVMu.MirMat(nx,ny,nz) # Calculate mirror matrix
nx,ny,nz = 1.0/np.sqrt(2.0) , 0.0 , 1.0/ | np.sqrt(2.0) | numpy.sqrt |
#######################################################################
# Copyright (C) #
# 2016-2018 <NAME>(<EMAIL>) #
# 2016 <NAME>(<EMAIL>) #
# 2017 <NAME>(<EMAIL>) #
# Permission given to modify the code as long as you keep this #
# declaration at the top #
#######################################################################
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
from tqdm import tqdm
# actions: hit or stand
ACTION_HIT = 0 # 拿牌
ACTION_STAND = 1 # "strike" in the book， 不拿牌
ACTIONS = [ACTION_HIT, ACTION_STAND]
# policy for player
POLICY_PLAYER = np.zeros(22, dtype=np.int)
for i in range(12, 20):
POLICY_PLAYER[i] = ACTION_HIT
POLICY_PLAYER[20] = ACTION_STAND
POLICY_PLAYER[21] = ACTION_STAND
# function form of target policy of player
def target_policy_player(usable_ace_player, player_sum, dealer_card):
return POLICY_PLAYER[player_sum]
# function form of behavior policy of player
def behavior_policy_player(usable_ace_player, player_sum, dealer_card):
if np.random.binomial(1, 0.5) == 1:
return ACTION_STAND
return ACTION_HIT
# policy for dealer
POLICY_DEALER = np.zeros(22)
for i in range(12, 17):
POLICY_DEALER[i] = ACTION_HIT
for i in range(17, 22):
POLICY_DEALER[i] = ACTION_STAND
# get a new card
def get_card_1_to_10():
"""
这个改为获取点数更合适
获取 1~10的裸点数，不考虑A为11的情况
:return:
"""
card = np.random.randint(1, 14)
card = min(card, 10)
return card
# get the value of a card (11 for ace).
def transform_ace_to_11(card_id):
return 11 if card_id == 1 else card_id
# play a game
# @policy_player: specify policy for player
# @initial_state: [whether player has a usable Ace, sum of player's cards, one card of dealer]
# @initial_action: the initial action
def play(policy_player, initial_state=None, initial_action=None):
# player status
# sum of player
player_sum = 0
# trajectory of player
player_trajectory = []
# whether player uses Ace as 11
usable_ace_player = False
# dealer status
dealer_card1 = 0
dealer_card2 = 0
usable_ace_dealer = False
if initial_state is None:
# generate a random initial state
while player_sum < 12:
# if sum of player is less than 12, always hit
card = get_card_1_to_10() # 获取 1~10的裸点数，不考虑A为11的情况
player_sum += transform_ace_to_11(card)
# If the player's sum is larger than 21, he may hold one or two aces.
if player_sum > 21:
assert player_sum == 22
# last card must be ace
player_sum -= 10 # 将其中一个A转为1
else:
usable_ace_player |= (1 == card)
# initialize cards of dealer, suppose dealer will show the first card he gets
dealer_card1 = get_card_1_to_10()
dealer_card2 = get_card_1_to_10()
else:
# use specified initial state
usable_ace_player, player_sum, dealer_card1 = initial_state
dealer_card2 = get_card_1_to_10()
# initial state of the game
state = [usable_ace_player, player_sum, dealer_card1]
# initialize dealer's sum （并且如果有A就转换为11点）
dealer_sum = transform_ace_to_11(dealer_card1) + transform_ace_to_11(dealer_card2)
usable_ace_dealer = 1 in (dealer_card1, dealer_card2)
# if the dealer's sum is larger than 21, he must hold two aces.
if dealer_sum > 21:
assert dealer_sum == 22
# use one Ace as 1 rather than 11
dealer_sum -= 10 # 将其中一个A转为1
assert dealer_sum <= 21
assert player_sum <= 21
# game starts!
# player's turn
while True:
if initial_action is not None:
action = initial_action
initial_action = None
else:
# get action based on current sum
action = policy_player(usable_ace_player, player_sum, dealer_card1)
# track player's trajectory for importance sampling
player_trajectory.append([(usable_ace_player, player_sum, dealer_card1), action])
# 停止要牌
if action == ACTION_STAND:
break
# 要牌
# if hit, get new card
card = get_card_1_to_10()
# 记录A的个数
# Keep track of the ace count. the usable_ace_player flag is insufficient alone as it cannot
# distinguish between having one ace or two.
ace_count = int(usable_ace_player)
if card == 1:
ace_count += 1
# 求和
player_sum += transform_ace_to_11(card)
# 如果超过21点，则把手中的A降为1点
while player_sum > 21 and ace_count:
player_sum -= 10
ace_count -= 1
# 超过21点，且没有A，爆点
if player_sum > 21:
return state, -1, player_trajectory
# 小于21点则继续
assert player_sum <= 21
usable_ace_player = (ace_count == 1)
# dealer's turn
while True:
# get action based on current sum
action = POLICY_DEALER[dealer_sum]
# 停止要牌
if action == ACTION_STAND:
break
# 要牌
# if hit, get a new card
new_card = get_card_1_to_10()
# 记录A的个数
ace_count = int(usable_ace_dealer)
if new_card == 1:
ace_count += 1
# 求和
dealer_sum += transform_ace_to_11(new_card)
# 如果超过21点，则把手中的A降为1点
# If the dealer has a usable ace, use it as 1 to avoid busting and continue.
while dealer_sum > 21 and ace_count:
dealer_sum -= 10
ace_count -= 1
# 超过21点，且没有A，爆点
# dealer busts
if dealer_sum > 21:
return state, 1, player_trajectory
# 小于21点则继续
usable_ace_dealer = (ace_count == 1)
# compare the sum between player and dealer
assert player_sum <= 21 and dealer_sum <= 21
if player_sum > dealer_sum:
return state, 1, player_trajectory
elif player_sum == dealer_sum:
return state, 0, player_trajectory
else:
return state, -1, player_trajectory
# Monte Carlo Sample with On-Policy
def monte_carlo_on_policy(episodes):
# state value 表格1（针对usable_ace）
states_usable_ace = np.zeros((10, 10))
# initialze counts to 1 to avoid 0 being divided
states_usable_ace_count = np.ones((10, 10))
# state value 表格2（针对no usable_ace）
states_no_usable_ace = np.zeros((10, 10))
# initialze counts to 1 to avoid 0 being divided
states_no_usable_ace_count = np.ones((10, 10))
for i in tqdm(range(0, episodes)):
# 1 个 episode
_, reward, player_trajectory = play(target_policy_player)
# episode结束后累积reward （以便后面求平均）
for (usable_ace, player_sum, dealer_card), _ in player_trajectory:
player_sum -= 12
dealer_card -= 1
if usable_ace:
states_usable_ace_count[player_sum, dealer_card] += 1
states_usable_ace[player_sum, dealer_card] += reward
else:
states_no_usable_ace_count[player_sum, dealer_card] += 1
states_no_usable_ace[player_sum, dealer_card] += reward
# 估计state value
return states_usable_ace / states_usable_ace_count, states_no_usable_ace / states_no_usable_ace_count
# Monte Carlo with Exploring Starts
def monte_carlo_es(episodes):
# (playerSum, dealerCard, usableAce, action)
state_action_values = | np.zeros((10, 10, 2, 2)) | numpy.zeros |
import pytest
import sympy
import numpy as np
import scipy.linalg as la
from .. import kwant_rmt
from ..hamiltonian_generator import continuum_hamiltonian, check_symmetry, \
bloch_family, make_basis_pretty, constrain_family, continuum_variables, \
continuum_pairing, remove_duplicates, subtract_family, display_family
from ..groups import PointGroupElement, Model, time_reversal, chiral, rotation
from ..model import _commutative_momenta, Model, BlochModel
from ..linalg import nullspace, family_to_vectors
def test_check_symmetry():
"""Test discrete symmetries for the Hamiltonian generator without momentum
dependence, and that antiunitary and anticommuting symmetries are correctly
treated in check_symmetry. """
# No momentum dependence
dim = 0
total_power = 0
n = 8
R = np.eye(dim, dtype=int)
for sym in kwant_rmt.sym_list:
symmetries = []
if kwant_rmt.p(sym):
p_mat = np.array(kwant_rmt.h_p_matrix[sym])
p_mat = np.kron(np.identity(n // len(p_mat)), p_mat)
symmetries.append(PointGroupElement(R, True, True, p_mat))
if kwant_rmt.t(sym):
t_mat = np.array(kwant_rmt.h_t_matrix[sym])
t_mat = np.kron(np.identity(n // len(t_mat)), t_mat)
symmetries.append(PointGroupElement(R, True, False, t_mat))
if kwant_rmt.c(sym):
c_mat = np.kron(np.identity(n // 2), np.diag([1, -1]))
symmetries.append(PointGroupElement(R, False, True, c_mat))
if len(symmetries):
Hamiltonian_family = continuum_hamiltonian(symmetries, dim, total_power)
# Check that the symmetries hold.
check_symmetry(Hamiltonian_family, symmetries)
# Also manually check that the family has the symmetries, to test
# the function check_symmetry.
# Check several random linear combinations of all family members.
for _ in range(5):
ham = sum([np.random.rand()*matrix for member in Hamiltonian_family
for matrix in member.values()])
# Iterate over all symmetries
for symmetry in symmetries:
Left = ham.dot(symmetry.U)
if symmetry.conjugate: # Symmetry is antiunitary
Right = symmetry.U.dot(ham.conj())
else: # Symmetry is unitary
Right = symmetry.U.dot(ham)
if symmetry.antisymmetry: # Symmetry anticommutes
assert np.allclose(Left + Right, 0)
else: # Symmetry commutes
assert np.allclose(Left - Right, 0)
def test_bloch_generator():
"""Square lattice with time reversal and rotation symmetry, such that all hoppings are real. """
# Time reversal
trU = np.eye(2)
trR = sympy.Matrix([[1, 0], [0, 1]])
trS = PointGroupElement(trR, True, False, trU)
# 2-fold rotation
rotU = | np.eye(2) | numpy.eye |
"""
Functions for converting text documents into vector space
and dealing with dirty data.
Features:
- no external dependencies
- feature selection methods:
- CHI
- WCP (Within Class Probability)
- CMFS (Comprehensively Measure Feature Selection)
- improved GINI
- CO matrix calcualtion
- DF calculation
- IDF calculation
"""
from multiprocessing import Pool
from collections import Counter
from itertools import groupby,chain
from math import log,ceil
import re
from batch import partitions as _partitions
# TODO resampling
# TODO przeniesienie feature selection do osobnego pliku
# TODO __init__.py
# TODO przyjecie nomenklatury t-term,c-category, tk, ci
# TODO reorder functions top-down vs bottom-up vs subject
# TODO smart lowercase (prosty NER w oparciu o DF[t] vs DF[t.lower])
# TODO sklearn model.fit/transform interface OR SIMILAR via functools.partial
# TODO liczenie lift dla co
# TODO wybieranie ngramow na podstawie liftu
# ---[ document frequency ]-----------------------------------------------------
def get_df_part(kwargs):
min_df_part = kwargs['min_df_part']
max_df_part = kwargs['max_df_part']
min_tf_doc = kwargs['min_tf_doc']
df = Counter()
for tokens in iter_tokens_part(kwargs):
if min_tf_doc:
unique_tokens = [t for t,f in Counter(tokens).items() if f>=min_tf_doc]
else:
unique_tokens = set(tokens)
df.update(unique_tokens)
# limit within partition
if min_df_part:
below = [t for t in df if df[t]<min_df_part]
for t in below:
del df[t]
if max_df_part < 1.0:
x = max_df_part * len(X)
above = [t for t in df if df[t]>x]
for t in above:
del df[t]
return df
# TODO option to include whole words shorter than char ngram_range 'lo' value
# TODO option to mark word begin/end in char ngrams
# TODO max_df float
# TODO max_df int
# TODO max_df_part float
# TODO min_df float
# TODO reorder ARGS
def get_df(X, workers=4, as_dict=True, partitions=None,
token_pattern='[\w][\w-]*', split_pattern='', encoding=None,
lowercase=True, min_df=0, min_df_part=0, max_df=1.0, max_df_part=1.0,
analyzer='word', tokenizer=None, preprocessor=None,
decode_error='strict', stop_words=None, mp_pool=None,
min_tf_doc=0, ngram_range=None, postprocessor=None, ngram_words=None):
"""Calculate document frequency from a collection of text documents.
Parameters
----------
X : iterable
Collection of text documents.
workers : int, default=4
partitions : int or None (default)
Number of partitons. By default it will be equal to number of
workers
token_pattern : string, default='[\w][\w-]*'
Regular expression denoting what constitute a "token".
Will not be used when tokenizer or split_pattern is defined.
split_pattern : string, default=''
Regular expression denoting what separetes "tokens".
Will not be used when tokenizer is defined.
ngram_range : tuple (lo, hi)
The lower and upper "n" for n-grams to be extracted
ngram_words: iterable or None (default)
Limit n-gram generation to cases where at least one word occurs
in the provided list.
encoding: string or None (default)
lowercase: boolean, default=True
analyzer: str {'word','char'}
Whether the features should be made of word or character n-grams.
Option 'char' creates character n-grams only from text inside
word boundaries.
tokenizer: callable or None (default)
Function which transforms text into list of tokens (before
postprocessing and n-gram generation).
preprocessor: callable, list of callable or None (default)
Function or list of functions which transforms text before tokenization.
postprocessor: callable, list of callable or None (default)
Function(s) or list of functions which transforms list of tokens (before n-gram
generation)
min_df: int, default=0
min_df_part: int, default=0
min_tf_doc: int, default=0
max_df: float, default=1.0
max_df_part: float, default=1.0
decode_error: str, default='strict'
stop_words: iterable or None (default)
mp_pool: multiprocessing.Pool or None (default)
Multiprocessing pool object that will be used to parallelize
execution. If none is provided a new one will be created.
as_dict: boolean, default=True
Whether the result should be converted into dict or left
as collections.Counter (which doesn't support marshaling)
"""
data = []
kwargs = dict(
token_pattern = token_pattern
,split_pattern = split_pattern
,encoding = encoding
,lowercase = lowercase
,min_df_part = min_df_part
,max_df_part = max_df_part
,analyzer = analyzer
,ngram_range = ngram_range
,tokenizer = tokenizer
,preprocessor = preprocessor
,decode_error = decode_error
,stop_words = stop_words
,min_tf_doc = min_tf_doc
,postprocessor = postprocessor
,ngram_words = ngram_words
)
part_cnt = partitions or workers
if mp_pool and not partitions:
part_cnt = max(part_cnt,len(mp_pool._pool))
for lo,hi in _partitions(len(X),part_cnt):
kw = dict(X=X[lo:hi], **kwargs)
data.append(kw)
pool = mp_pool or Pool(workers)
df_partitions = pool.map(get_df_part, data)
df=df_partitions[0]
for df_ in df_partitions[1:]:
df.update(df_)
if min_df:
below = [t for t in df if df[t]<min_df]
for t in below:
del df[t]
if max_df < 1.0:
max_df_cnt = max_df * len(X)
above = [t for t in df if df[t]>max_df_cnt]
for t in above:
del df[t]
if as_dict:
df = dict(df)
return df
### 24s get_dfy vs 11s get_df vs 25s get_dfy2(specialized)
def get_dfy(X,Y,workers=4,sort=True,mp_pool=None,**kwargs):
"""Calcualte per topic document frequency.
"""
dfy = {}
if sort:
data = sorted(zip(Y,X))
else:
data = zip(Y,X)
pool = mp_pool or Pool(workers)
for y,g in groupby(data,lambda x:x[0]):
x = [v[1] for v in g]
dfy[y] = get_df(x,mp_pool=pool,**kwargs)
return dfy
def get_df_from_dfy(dfy,as_dict=True):
"""Convert per topic document frequency into total document frequency.
"""
df = Counter()
for y in dfy:
df.update(dfy[y])
if as_dict:
df = dict(df)
return df
# ---[ clean ]------------------------------------------------------------------
def limit_df(df,min_tokens=2,token_pattern='[\w][\w-]*', split_pattern='', tokenizer=None):
"""function for limiting noise df to sentences with minimum number of tokens"""
if token_pattern:
re_tok = re.compile(token_pattern,re.U)
if split_pattern:
re_split = re.compile(split_pattern,re.U)
new_df = {}
for t in df:
if tokenizer:
tokens = tokenizer(t)
elif split_pattern:
tokens = re_split.split(t)
elif token_pattern:
tokens = re_tok.findall(t)
if len(tokens)<min_tokens:
continue
new_df[t] = df[t]
return new_df
# TODO replace based on matched split_pattern
def get_clean_x_part(kwargs):
replace = kwargs['replace']
out = []
for tokens in iter_tokens_part(kwargs):
out.append(replace.join(tokens))
return out
# TODO refactor with get_df
def get_clean_x(X, workers=4, partitions=None,
token_pattern='[\w][\w-]*', split_pattern='', encoding=None,
lowercase=True,
tokenizer=None, preprocessor=None,
decode_error='strict', stop_words=None, mp_pool=None,
postprocessor=None,
replace=u' ; ', stop_hashes=None, hash_fun=None):
"""Replace noise tokens (words/phrases).
Parameters
----------
X : iterable
Collection of text documents.
stop_words : iterable or None (default)
Collection of tokens that should be replaced
stop_hashes : iterable or None (default)
Collection of hashes of tokens that should be replaced
replace : str, default=u' ; '
Replacement text for noise tokens
workers : int, default=4
token_pattern : string, default='[\w][\w-]*'
Regular expression denoting what constitute a "token".
Will not be used when tokenizer or split_pattern is defined.
... TODO rest of params
"""
data = []
part_cnt = partitions or workers
if mp_pool and not partitions:
part_cnt = max(part_cnt,len(mp_pool._pool))
for lo,hi in _partitions(len(X),part_cnt):
kwargs = dict(
X = X[lo:hi]
,token_pattern = token_pattern
,split_pattern = split_pattern
,encoding = encoding
,lowercase = lowercase
,tokenizer = tokenizer
,preprocessor = preprocessor
,decode_error = decode_error
,stop_words = stop_words
,postprocessor = postprocessor
,replace = replace
,stop_hashes = stop_hashes
,hash_fun = hash_fun
)
data.append(kwargs)
pool = mp_pool or Pool(workers)
x_partitions = pool.map(get_clean_x_part, data)
x=x_partitions[0]
for x_ in x_partitions[1:]:
x.extend(x_)
return x
# ---[ feature selection ]------------------------------------------------------
def get_idf(df, n, a1=1, a2=1, a3=1, min_df=0):
"""Calculate inverse document frequency.
"""
idf = Counter()
for t in df:
if min_df and df[t]<min_df: continue
idf[t] = log( (a1+n) / (a2+df[t]) ) + a3
return idf
# TODO mcd
def get_chiy(df,n,dfy,ny,alpha=0):
chiy = {}
for y in dfy:
chiy[y] = get_chi(df,n,dfy[y],ny[y],alpha)
return chiy
# TODO rename dfy,ny
def get_chi(df,n,dfy,ny,alpha=0):
"""Calculate chi scores for features from one topic
"""
chi = {}
for t,val in iter_chi(df,n,dfy,ny,alpha):
chi[t] = val
return chi
# TODO rename dfy,ny
def get_chi_explain(df,n,dfy,ny,alpha=0):
chi_explain = iter_chi(df,n,dfy,ny,alpha,explain=True)
return dict(chi_explain)
# TODO rename dfy,ny -> dfc (class), dft (topic)
# TODO rename chi variables
def iter_chi(df,n,dfy,ny,alpha=0,explain=False):
all = df
topic = dfy
for t in df:
# observed
o_c1_t1 = topic.get(t,0)
o_c1_t0 = ny - topic.get(t,0)
o_c0_t1 = all[t] - topic.get(t,0)
o_c0_t0 = n - o_c1_t1 - o_c1_t0 - o_c0_t1
# expected
e_c1_t1 = 1.0 * ny * all[t]/n
e_c1_t0 = 1.0 * ny * (n-all[t])/n
e_c0_t1 = 1.0 * (n-ny)/n * all[t]
e_c0_t0 = 1.0 * (n-ny)/n * (n-all[t])
# chi components
c1_t1 = (o_c1_t1 - e_c1_t1)**2 / (e_c1_t1 + alpha)
c1_t0 = (o_c1_t0 - e_c1_t0)**2 / (e_c1_t0 + alpha)
c0_t1 = (o_c0_t1 - e_c0_t1)**2 / (e_c0_t1 + alpha)
c0_t0 = (o_c0_t0 - e_c0_t0)**2 / (e_c0_t0 + alpha)
# chi
chi = c0_t0 + c1_t0 + c0_t1 + c1_t1
# result
if explain:
ex = dict()
ex['o_c1_t1'] = o_c1_t1
ex['o_c1_t0'] = o_c1_t0
ex['o_c0_t1'] = o_c0_t1
ex['o_c0_t0'] = o_c0_t0
ex['e_c1_t1'] = e_c1_t1
ex['e_c1_t0'] = e_c1_t0
ex['e_c0_t1'] = e_c0_t1
ex['e_c0_t0'] = e_c0_t0
ex['c1_t1'] = c1_t1
ex['c1_t0'] = c1_t0
ex['c0_t1'] = c0_t1
ex['c0_t0'] = c0_t0
ex['chi'] = chi
ex = {k:int(v) for k,v in ex.items()}
yield t,ex
else:
yield t,chi
# TODO gini(wcp) ???
def iter_wcpy(df,dfy,explain=False):
topics = dfy.keys()
V = len(df)
for t in df:
wcpy = {}
py = {}
for y in topics:
nom = 1 + dfy[y].get(t,0)
denom = V + df[t]
py[y] = 1.0 * nom / denom
sum_py = sum(py.values())
for y in topics:
wcpy[y] = py[y] / sum_py
if explain:
ex = dict()
# TODO
yield t,ex
else:
yield t,wcpy
def iter_giniy(df,dfy,ny,explain=False):
topics = dfy.keys()
for t in df:
giniy = {}
for y in topics:
p_t_when_y = 1.0 * dfy[y].get(t,0) / ny[y]
p_y_when_t = 1.0 * dfy[y].get(t,0) / df[t]
giniy[y] = p_t_when_y**2 + p_y_when_t**2
if explain:
ex = dict()
# TODO
yield t,ex
else:
yield t,giniy
def iter_cmfsy(df,dfy,explain=False):
topics = dfy.keys()
C = len(topics)
V = len(df)
sum_dfy = {y:sum(dfy[y].values()) for y in topics}
for t in df:
cmfsy = {}
for y in topics:
nom = dfy[y].get(t,0) + 1
denom1 = df[t] + C
denom2 = sum_dfy[y] + V
cmfsy[y] = 1.0 * nom / (denom1 * denom2)
if explain:
ex = dict()
# TODO
yield t,ex
else:
yield t,cmfsy
def get_giniy(df, dfy, ny):
"""Calculate improved GINI for all topics
"""
items = iter_giniy(df,dfy,ny)
topics = dfy.keys()
return transform_items_topics(items, topics)
def get_cmfsy(df, dfy):
"""
http://www.dafl.yuntech.edu.tw/download/2012.IPM.48.A%20new%20feature%20selection%20based%20on%20comprehensive%20measurement%20both%20in%20inter-category%20and%20intra-category%20for%20text%20categorization.pdf
"""
items = iter_cmfsy(df,dfy)
topics = dfy.keys()
return transform_items_topics(items, topics)
def get_wcpy(df, dfy):
"""Calculate WCP for all topics
"""
items = iter_wcpy(df, dfy)
topics = dfy.keys()
return transform_items_topics(items, topics)
# TODO opisac
def get_mcdy(fsy):
"minimal class difference of feature score"
topics = fsy.keys()
mcdy = {y:{} for y in topics}
vocab = set()
for y in topics:
vocab.update(fsy[y])
for t in vocab:
for y in topics:
val = min([abs(fsy[y].get(t,0)-fsy[y2].get(t,0)) for y2 in topics if y!=y2])
if val:
mcdy[y][t] = val
return mcdy
# ---[ vectorization ]----------------------------------------------------------
# TODO token_id iter not token_cnt
# TODO refactor using iter_tokens_part
def vectorize_part(kwargs):
vocabulary = kwargs['vocabulary']
binary = kwargs['binary']
sparse = kwargs['sparse']
stream = kwargs['stream']
upper_limit = kwargs['upper_limit']
dtype = kwargs['dtype']
if dtype:
import numpy as np
typecode = kwargs['typecode']
if typecode:
from array import array
if vocabulary==None:
pass
elif callable(vocabulary):
pass
elif hasattr(vocabulary,'items'):
vocab_dict = vocabulary
vocab_len = max(vocab_dict.values()) + 1
else:
vocab_dict = {t:t_id for t_id,t in enumerate(vocabulary)}
vocab_len = len(vocabulary)
out = []
for tokens in iter_tokens_part(kwargs):
# TODO filter tokens - keep only vocabulary -> here or after ngrams ???
# output
if stream:
v = []
if vocabulary==None:
v.extend(tokens)
elif callable(vocabulary):
for t in tokens:
v.append(vocabulary(t))
else:
empty = True # detection and removal of empty tokens combos
for t in tokens:
if t not in vocab_dict:
continue # XXX
if not empty:
v.append(0) # XXX
empty = True
#continue # TODO optional -1 token
else:
t_id = vocab_dict[t]
v.append(t_id)
empty = False
if dtype:
v = np.array(v,dtype=dtype)
if typecode:
v = array(typecode,v)
elif sparse:
if binary:
v = [vocab_dict[t] for t in set(tokens) if t in vocab_dict]
if dtype:
v = np.array(v,dtype=dtype)
if typecode:
v = array(typecode,v)
else:
tf = {}
for t in tokens:
if t not in vocab_dict: continue
t_id = vocab_dict[t]
if t_id not in tf: tf[t_id]=1
else:
tf[t_id]+=1
if upper_limit:
for t in tf:
tf[t] = min(upper_limit,tf[t])
v = tf
if dtype:
v = np.array(tf.items(),dtype=dtype)
if typecode:
pass # TODO
else:
v = [0]*vocab_len
if binary:
for t in tokens:
if t not in vocab_dict: continue
t_id = vocab_dict[t]
v[t_id] = 1
else:
for t in tokens:
if t not in vocab_dict: continue
t_id = vocab_dict[t]
v[t_id] += 1
if dtype:
v = | np.array(v, dtype=dtype) | numpy.array |
#!/usr/bin/env python
# coding: utf-8
# In[ ]:
from emojinator_files.utils import detector_utils as detector_utils
import cv2
from keras.models import load_model
import numpy as np
import os
from collections import deque
from flask import Flask,render_template,Response, redirect, url_for
import time
app=Flask(__name__)
def setValues(x):
print("")
def generate_frames(colorIndex,colors,kernel,bpoints,gpoints,rpoints,ypoints,bkpoints, blue_index,green_index,red_index,yellow_index, black_index):
cap = cv2.VideoCapture(0)
canvas = None
while True:
ret, frame = cap.read()
frame = cv2.flip(frame, 1)
if canvas is None:
canvas = np.zeros_like(frame)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
u_hue = cv2.getTrackbarPos("Upper Hue", "Color detectors")
u_saturation = cv2.getTrackbarPos("Upper Saturation", "Color detectors")
u_value = cv2.getTrackbarPos("Upper Value", "Color detectors")
l_hue = cv2.getTrackbarPos("Lower Hue", "Color detectors")
l_saturation = cv2.getTrackbarPos("Lower Saturation", "Color detectors")
l_value = cv2.getTrackbarPos("Lower Value", "Color detectors")
Upper_hsv = np.array([u_hue,u_saturation,u_value])
Lower_hsv = np.array([l_hue,l_saturation,l_value])
frame = cv2.rectangle(frame, (40,1), (140,65), (122,122,122), -1)
frame = cv2.rectangle(frame, (160,1), (255,65), colors[0], -1)
frame = cv2.rectangle(frame, (275,1), (370,65), colors[1], -1)
frame = cv2.rectangle(frame, (390,1), (485,65), colors[2], -1)
frame = cv2.rectangle(frame, (505,1), (600,65), colors[3], -1)
frame = cv2.rectangle(frame, (570,422), (640,480), (122,122,122), -1)
frame = cv2.rectangle(frame, (0,422), (70,480), (122,122,122), -1)
cv2.putText(frame, "CLEAR ALL", (49, 33), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame, "BLUE", (185, 33), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame, "GREEN", (298, 33), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame, "RED", (420, 33), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame, "YELLOW", (520, 33), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (150,150,150), 2, cv2.LINE_AA)
cv2.putText(frame, "PAUSE", (582, 455), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame, "ERASE", (10, 455), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2, cv2.LINE_AA)
Mask = cv2.inRange(hsv, Lower_hsv, Upper_hsv)
Mask = cv2.erode(Mask, kernel, iterations=1)
Mask = cv2.morphologyEx(Mask, cv2.MORPH_OPEN, kernel)
Mask = cv2.dilate(Mask, kernel, iterations=1)
cnts,_ = cv2.findContours(Mask.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
center = None
if len(cnts) > 0:
cnt = sorted(cnts, key = cv2.contourArea, reverse = True)[0]
((x, y), radius) = cv2.minEnclosingCircle(cnt)
cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2)
M = cv2.moments(cnt)
center = (int(M['m10'] / M['m00']), int(M['m01'] / M['m00']))
if center[1] >= 422 and center[0] >= 570:
break
if center[1] >= 422 and center[0] <= 70:
colorIndex = 4
if center[1] <= 65:
if 40 <= center[0] <= 140:
bpoints = [deque(maxlen=512)]
gpoints = [deque(maxlen=512)]
rpoints = [deque(maxlen=512)]
ypoints = [deque(maxlen=512)]
bkpoints = [deque(maxlen=512)]
blue_index = 0
green_index = 0
red_index = 0
yellow_index = 0
canvas[67:,:,:] = 0
elif 160 <= center[0] <= 255:
colorIndex = 0
elif 275 <= center[0] <= 370:
colorIndex = 1
elif 390 <= center[0] <= 485:
colorIndex = 2
elif 505 <= center[0] <= 600:
colorIndex = 3
else :
if colorIndex == 0:
bpoints[blue_index].appendleft(center)
elif colorIndex == 1:
gpoints[green_index].appendleft(center)
elif colorIndex == 2:
rpoints[red_index].appendleft(center)
elif colorIndex == 3:
ypoints[yellow_index].appendleft(center)
else:
bpoints.append(deque(maxlen=512))
blue_index += 1
gpoints.append(deque(maxlen=512))
green_index += 1
rpoints.append(deque(maxlen=512))
red_index += 1
ypoints.append(deque(maxlen=512))
yellow_index += 1
points = [bpoints, gpoints, rpoints, ypoints]
for i in range(len(points)):
for j in range(len(points[i])):
for k in range(1, len(points[i][j])):
if points[i][j][k - 1] is None or points[i][j][k] is None:
continue
cv2.line(canvas, points[i][j][k - 1], points[i][j][k], colors[i], 2)
_ , mask = cv2.threshold(cv2.cvtColor (canvas, cv2.COLOR_BGR2GRAY), 20,
255, cv2.THRESH_BINARY)
foreground = cv2.bitwise_and(canvas, canvas, mask = mask)
background = cv2.bitwise_and(frame, frame,
mask = cv2.bitwise_not(mask))
frame = cv2.add(foreground,background)
# cv2.imshow("Tracking", canvas)
# cv2.imshow("Paint", paintWindow)
cv2.imshow("mask",Mask)
ret, buffer = cv2.imencode('.jpg', frame)
frame = buffer.tobytes()
yield (b'--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n') # concat frame one by one and show result
if cv2.waitKey(1) & 0xFF == ord("q"):
break
cap.release()
cv2.destroyAllWindows()
#def setValues(x):
# print("")
def updated_generate_frames():
load_from_disk = True
if load_from_disk:
penval = np.load('penval.npy')
cap = cv2.VideoCapture(0)
# Load these 2 images and resize them to the same size.
# pen_img = cv2.resize(cv2.imread('air canvas files/pen.png',1), (50, 50))
# eraser_img = cv2.resize(cv2.imread('air canvas files/eraser.jpg',1), (50, 50))
kernel = np.ones((5,5),np.uint8)
# Making window size adjustable
cv2.namedWindow('image', cv2.WINDOW_NORMAL)
# This is the canvas on which we will draw upon
canvas = None
# Create a background subtractor Object
backgroundobject = cv2.createBackgroundSubtractorMOG2(detectShadows = False)
# This threshold determines the amount of disruption in the background.
background_threshold = 600
# A variable which tells you if you're using a pen or an eraser.
switch = 'Pen'
# With this variable we will monitor the time between previous switch.
last_switch = time.time()
# Initilize x1,y1 points
x1,y1=0,0
# Threshold for noise
noiseth = 800
# Threshold for wiper, the size of the contour must be bigger than this for # us to clear the canvas
wiper_thresh = 40000
# A variable which tells when to clear canvas
clear = False
colorIndex=0
while(1):
_, frame = cap.read()
frame = cv2.flip( frame, 1 )
# Initilize the canvas as a black image
if canvas is None:
canvas = np.zeros_like(frame)
colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (0, 255, 255), (0,0,0)]
# Take the top left of the frame and apply the background subtractor
# there
# top_left = frame[422: 480, 0: 70]
# fgmask = backgroundobject.apply(top_left)
# # Note the number of pixels that are white, this is the level of
# # disruption.
# switch_thresh = np.sum(fgmask==255)
# # If the disruption is greater than background threshold and there has
# # been some time after the previous switch then you. can change the
# # object type.
# if switch_thresh>background_threshold and (time.time()-last_switch) > 1:
# # Save the time of the switch.
# last_switch = time.time()
# if switch == 'Pen':
# switch = 'Eraser'
# else:
# switch = 'Pen'
# Convert BGR to HSV
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# If you're reading from memory then load the upper and lower ranges
# from there
if load_from_disk:
lower_range = penval[0]
upper_range = penval[1]
# Otherwise define your own custom values for upper and lower range.
else:
lower_range = | np.array([26,80,147]) | numpy.array |
import numpy as np
import tensorflow as tf
import gzip
import os
import platform
import pickle
class DataSet(object):
def __init__(self, dataSetName, is_IID, dtype=tf.float32):
dype = tf.as_dtype(dtype).base_dtype
if dtype not in (tf.uint8, tf.float32):
raise TypeError('Invalid image dtype {}, expected uint8 or float32'.format(dtype))
self.name = dataSetName
self.train_data = None
self.train_label = None
self.test_data = None
self.test_label = None
self.train_data_size = None
self.test_data_size = None
self._index_in_train_epoch = 0
if self.name == 'mnist':
self.mnist_dataset_construct(is_IID, dtype)
elif self.name == 'cifar10':
self.cifar10_dataset_construct(is_IID)
else:
pass
def mnist_dataset_construct(self, is_IID, dtype):
data_dir = r'./data/MNIST'
train_images_path = os.path.join(data_dir, 'train-images-idx3-ubyte.gz')
train_labels_path = os.path.join(data_dir, 'train-labels-idx1-ubyte.gz')
test_images_path = os.path.join(data_dir, 't10k-images-idx3-ubyte.gz')
test_labels_path = os.path.join(data_dir, 't10k-labels-idx1-ubyte.gz')
train_images = extract_images(train_images_path)
train_labels = extract_labels(train_labels_path)
test_images = extract_images(test_images_path)
test_labels = extract_labels(test_labels_path)
assert train_images.shape[0] == train_labels.shape[0]
assert test_images.shape[0] == test_labels.shape[0]
self.train_data_size = train_images.shape[0]
self.test_data_size = test_images.shape[0]
assert train_images.shape[3] == 1
assert test_images.shape[3] == 1
train_images = train_images.reshape(train_images.shape[0], train_images.shape[1] * train_images.shape[2])
test_images = test_images.reshape(test_images.shape[0], test_images.shape[1] * test_images.shape[2])
if dtype == tf.float32:
train_images = train_images.astype(np.float32)
train_images = np.multiply(train_images, 1.0 / 255.0)
test_images = test_images.astype(np.float32)
test_images = np.multiply(test_images, 1.0 / 255.0)
if is_IID == 1:
order = np.arange(self.train_data_size)
np.random.shuffle(order)
self.train_data = train_images[order]
self.train_label = train_labels[order]
else:
labels = np.argmax(train_labels, axis=1)
order = np.argsort(labels)
self.train_data = train_images[order]
self.train_label = train_labels[order]
self.test_data = test_images
self.test_label = test_labels
def cifar10_dataset_construct(self, is_IID):
images, labels = [], []
for filename in ['./data/CIFAR-10/cifar-10-batches-py/data_batch_{}'.format(i) for i in range(1, 6)]:
with open(filename, 'rb') as fo:
if 'Windows' in platform.platform():
cifar10 = pickle.load(fo, encoding='bytes')
elif 'Linux' in platform.platform():
cifar10 = pickle.load(fo, encoding='bytes')
for i in range(len(cifar10[b'labels'])):
image = np.reshape(cifar10[b'data'][i], (3, 32, 32))
image = np.transpose(image, (1, 2, 0))
image = image.astype(float)
images.append(image)
labels += cifar10[b'labels']
images = np.array(images, dtype='float')
labels = np.array(labels, dtype='int')
# self.train_data, self.train_label = images, labels
if is_IID == 1:
order = np.arange(images.shape[0])
np.random.shuffle(order)
self.train_data = images[order]
self.train_label = dense_to_one_hot(labels[order])
else:
order = np.argsort(labels)
self.train_data = images[order]
self.train_label = dense_to_one_hot(labels[order])
images, labels = [], []
with open(r'./data//CIFAR-10/cifar-10-batches-py/test_batch', 'rb') as fo:
if 'Windows' in platform.platform():
cifar10 = pickle.load(fo, encoding='bytes')
elif 'Linux' in platform.platform():
cifar10 = pickle.load(fo, encoding='bytes')
for i in range(len(cifar10[b'labels'])):
image = np.reshape(cifar10[b'data'][i], (3, 32, 32))
image = np.transpose(image, (1, 2, 0))
image = image.astype(float)
images.append(image)
labels += cifar10[b'labels']
images = np.array(images, dtype='float')
labels = np.array(labels, dtype='int')
self.test_label = dense_to_one_hot(labels)
self.test_data = []
shape = (24, 24, 3)
for i in range(images.shape[0]):
old_image = images[i, :, :, :]
old_image = np.pad(old_image, [[4, 4], [4, 4], [0, 0]], 'constant')
left = int((old_image.shape[0] - shape[0]) / 2)
top = int((old_image.shape[1] - shape[1]) / 2)
old_image = old_image[left: left + shape[0], top: top + shape[1], :]
mean = np.mean(old_image)
std = np.max([ | np.std(old_image) | numpy.std |
# -*- coding: utf-8 -*-
"""aula_python_4.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/10JwswxJwA6xL3sSl9tIH0HMp3-ZLC5gH
# Revisão
def inicia a definição de uma função
"""
def parabola(x, a, b, c):
y = a * x ** 2 + b * x + c
return y
parabola(1, 5, 2, 4)
"""Funções com argumentos com valor padrão:"""
def parabola_2(x, a=5, b=2, c=4):
y = a * x ** 2 + b * x + c
return y
parabola_2(1, 6, 7, 8)
"""Funções anônimas podem ser criadas com a palavra-chave lambda. As funções lambdas são restritas a uma única (em geral pequena) expressão. """
f2 = lambda x: x ** 2
f2(5)
f_soma = lambda a, b: a + b
f_soma(5, 9)
"""# Estrutura de dados
Veja a seguir mais métodos de objetos do tipo lista:
"""
l = [5, 18, 43, 77, 91, 18, 77]
"""Adicionar um elemento ao final da lista"""
l.append(100)
print(l)
"""Inserir um elemento em uma dada posição. Nesse caso insere o elemento 9 na posição de índice 1. """
l.insert(1, 9)
print(l)
"""Remover o primeiro elemento da lista que tem valor igual ao argumento (nesse caso remove o elemento 18)"""
l.remove(18)
print(l)
"""Contar o número de vezes que um elemento aparece na lista"""
l.count(77)
print(l)
"""Remover o elemento em uma dada posição. Esse método remove o elemento e o retorna.
Nesse caso remove o elemento de índice 1.
"""
l.pop(1)
print(l)
"""Devolver o índice do primeiro elemento cujo valor é igual ao argumento (nesse caso 91)
"""
l.index(91)
l.index(77)
l.index(53)
"""Ordenar os elementos da lista"""
print("lista:", l)
l.sort()
print("lista ordenada:", l)
"""Ordenar em ordem reversa"""
l = [5, 43, 77, 91, 18, 77, 100] # definindo novamente a lista l
l.sort(reverse=True)
print(l)
"""Inverter a ordem dos elementos"""
l = [5, 43, 77, 91, 18, 77, 100] # definindo novamente a lista l
l.reverse()
print(l)
"""Copiar os elementos da lista"""
l_c = l.copy()
print(l_c)
"""Para iterar sobre uma lista, a posição e o valor podem ser obtidos simultaneamente com a função enumerate()"""
for i, v in enumerate(l_c):
print(i, v)
"""Para percorrer duas ou mais listas ao mesmo tempo, as entradas podem ser pareadas com a função zip()"""
l1 = [2.5, 3.9, 8.7] # definindo lista l1
l2 = [8.7, 23.4, 12.5] # definindo lista l2
for a, b in zip(l1, l2):
print(a, b)
"""Uma lista pode ser percorrida na ordem inversa com a função reversed()"""
for z in reversed(range(10)):
print(z)
"""**Compreensões de listas**
Compreensões de listas são uma maneira concisa de criar uma lista. Uma aplicação comum é criar uma nova lista onde cada elemento é resultante da avaliação de uma expressão no contexto das cláusulas for e if.
Por exemplo, podemos criar uma lista com os quadrados desta forma:
"""
quadrados = [] # cria uma lista vazia e armazena na variável quadrados
for x in range(10):
quadrados.append(x ** 2)
print(quadrados)
"""Alternativamente, podemos fazer:"""
quadrados2 = [x ** 2 for x in range(10)]
print(quadrados2)
quadrados3 = list(map(lambda x: x ** 2, range(10)))
print(quadrados3)
"""**Tuplas**
Uma tupla consiste em uma sequência de valores separados por vírgulas. Na sua criação os valores de uma tupla podem ser envolvidos ou não por parênteses. Na saída do console tuplas são sempre envolvidas por parênteses. Apesar de serem similares às listas, as tuplas são frequentemente utilizadas em situações e com propósitos distintos. O principal motivo é que tuplas são imutáveis, enquanto listas são mutáveis.
"""
t = 5, 87, 'bla'
print(t)
"""Tuplas podem ser indexadas
"""
print(t[2])
"""É possível criar uma tupla contendo outras tuplas
"""
u = t, (56, 89, 346)
print(u[0][0])
"""Tuplas são **imutáveis**!"""
t[0] = 65
v = (27.6, 45.9) # 'empacotamento' de dois valores em uma tupla
vx, vy = v # processo inverso de 'desempacotamento' também é possível
print(vx)
"""
**Dicionários**
Uma estrutura de dados muito útil é o dicionário. Eles são indexados por palavras-chaves (keys), que podem ser de qualquer tipo imutável. Os dicionários são delimitados por {} e contém uma lista de pares chave:valor separados por vírgulas. O dicionário vazio é {}. Os dicionários são utilizados para armazenar e recuperar valores a partir das palavras-chaves. É possivel substituir uma valor de uma chave por um novo valor. """
ramais = {'Cristina': 6473, 'Ana': 6486, 'Marina': 7256, 'Allan': 7257, 'Gustavo': 7257}
print(ramais['Marina'])
"""Remover um par chave:valor"""
del (ramais['Allan'])
print(ramais)
"""Incluir novo par chave:valor"""
ramais['Charles'] = 6486
print(ramais)
"""Alterar o valor de uma chave"""
ramais['Cristina'] = 6478
print(ramais)
"""Listar todas as chaves presentes no dicionário """
list(ramais)
"""Verificar se uma palavra-chave está ou não no dicionário"""
'Cristina' in ramais
'Sandra' in ramais
"""O construtor dict cria um dicionário a partir de sequências de pares chave,valor"""
dict([('Cristina', 6473), ('Ana', 6486), ('Marina', 7256)])
dict(Allan=7257, Charles=6486)
"""As compreensões de dicionário também podem ser usadas para criar dicionários a partir de expressões"""
dici = {x: x ** 2 for x in range(10)}
print(dici)
"""Ao iterar sobre dicionários, a chave e o valor podem ser obtidos simultaneamente usando o método items()"""
for nome, fone in ramais.items():
print(nome, fone)
"""# Módulos
Uma boa prática ao escrever códigos maiores é dividí-lo em arquivos menores, o que pode facilitar a manutenção.
Um módulo é um arquivo contendo definições e instruções Python. O nome do arquivo é o nome do módulo acrescido do sufixo .py.
Um módulo também pode ser muito útil para escrever funções que são usadas em vários programas diferentes. É preferível usar um arquivo separado para uma função do que copiá-la para dentro de vários programas.
Por exemplo, usando um editor de texto, foi criado um arquivo chamado fibonacci.py, contendo as funções fib e fib_lista, apresentadas na última aula. Ao importar um módulo, as funções definidas no arquivo são colocadas diretamente na tabelas de símbolos atual e poderão ser chamadas e executadas.
"""
import fibonacci
fibonacci.fib(20)
fibonacci.fib_lista(50)
"""Módulos podem importar outros módulos. É costume colocar todos os comandos de import no início do módulo ou de um programa.
Outras maneiras de importar as definições de um módulo são:
"""
from fibonacci import fib, fib_lista
from fibonacci import *
# Importa todos os nomes definidos em um módulo
# Nem sempre aconselhado, pois introduz um conjunto desconhecido de nomes no ambiente,
# podendo levar a conflitos com outros nomes previamente definidos
import fibonacci as fibo
fibo.fib(10)
from fibonacci import fib_lista as f_l
f_l(30)
"""O Python guarda versões compiladas de cada módulo no diretório \__ pycache__ com o nome modulo.versão.pyc para acelerar o carregamento de módulos.
# Pacotes
Os pacotes são uma maneira de estruturar o “espaço de nomes” (namespace) dos módulos Python. Eles são uma coleção de módulos. Nos referimos a um módulo dentro de um pacote como nomedopacote.nomedomodulo.
Os arquivos \__ init__.py são necessários para que o Python trate diretórios contendo o arquivo como pacotes. \__ init__.py pode ser apenas um arquivo vazio.
O pacote **math** contém todas as funções matemáticas padrão (sqrt,log, log10, exp, funções trigonométricas).
"""
from math import log
x = log(3)
print(x)
from math import pi
print(pi)
from math import exp
from math import sin, cos
from math import *
# Algoritmo para converter a posição de um ponto dada em coordenadas polares (r,theta) para coordenadas
# Cartesianas (x,y)
from math import sin, cos, pi
r = float(input('Entre o valor de r: '))
d = float(input('Entre o valor de theta em graus: '))
theta = d * pi / 180. # conversão de graus para radianos
x = r * cos(theta)
y = r * sin(theta)
print('x=', x, 'y=', y)
"""O pacote **numpy** é fundamental para computação científica com Python. Ele oferece funções matemáticas, geradores de números aleatórios, rotinas de álgebra linear, transformada de Fourier e muito mais. Mas o seu poder está em permitir cálculos em arrays multidimensionais.
O numpy executa facilmente cálculos numéricos que são muito utilizados em problemas de machine learning (aprendizado de máquina) e de processamento de imagem (imagens no computador são representadas como arrays multidimensionais de números). Além disso, o numpy oferece várias outras tarefas matemáticas.
Para mais informações, consulte https://numpy.org/.
# Arrays
Um array é um conjunto ordenado de valores. Mas há diferenças importantes entre listas e arrays:
* O número de elementos de um array é fixo e não é possível adicionar ou remover elementos de um array após criá-lo;
* Os elementos de um array devem ser todos de um mesmo tipo, como float ou inteiros.
As principais vantagens de usar arrays em vez de listas são:
* Arrays podem ter qualquer número de dimensões. Arrays unidimensionais e bidimensionais são, respectivamente, como vetores e matrizes em álgebra linear. Listas são sempre unidimensionais.
* Como se comportam como vetores ou matrizes, podemos fazer qualquer aritmética com eles, ao contrário de listas.
* Arrays funcionam mais rápido que listas em Python.
Cada dimensão de um array é chamada axis. O número de axes é chamada de rank do array. A indexação dos arrays também começa em 0, com um número para cada axis do array.
"""
from numpy import array
a = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a)
# Minha recomendação
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a)
type(a) # checar que o tipo é um numpy array
a.dtype # fornece o tipo dos elementos do array
a.shape # dimensões do array
a.ndim # número de dimensões
a.size # número de elementos
"""Indexação de um array: o índice da linha vem primeiro e depois o da coluna"""
print(a)
print(a[2, 1])
a[1, 0:2]
"""Iterando sobre um array
"""
b = np.array([0, 2, 5, 8], dtype=int)
print(b)
for z in b:
print(z)
for i in range(len(b)):
print(b[i])
"""Outras formas de criar arrays
"""
a0 = np.zeros(5)
print(a0)
a0_2 = np.zeros([3, 4])
print(a0_2)
a1 = np.ones(7)
print(a1)
a1_2 = np.ones([2, 3])
print(a1_2)
a1_3 = | np.ones([2, 3, 4]) | numpy.ones |
import os
import sys
baseName = os.path.basename(__file__)
dirName = os.path.dirname(__file__)
print("basename: ", baseName)
print("dirname: ", dirName)
sys.path.append(dirName + r"/../..")
import pandas as pd
import numpy as np
from RFEM.initModel import *
from RFEM.BasicObjects.node import Node
from RFEM.BasicObjects.material import Material
from RFEM.BasicObjects.section import Section
from RFEM.BasicObjects.member import Member
from RFEM.BasicObjects.line import Line
def util_num_to_ndarray(nodes: np.ndarray, nums):
arr = np.array([])
if isinstance(nums, (int, float)):
arr = np.array([nums] * nodes.shape[0]).flatten()
elif isinstance(nums, list):
arr = np.array(nums).flatten()
elif isinstance(nums, np.ndarray):
arr = | np.array([nums]) | numpy.array |
"""
===============
emc2.core.Model
===============
This module contains the Model class and example Models for your use.
"""
import xarray as xr
import numpy as np
from act.io.armfiles import read_netcdf
from .instrument import ureg, quantity
from netCDF4 import Dataset
try:
from wrf import tk, getvar, ALL_TIMES
WRF_PYTHON_AVAILABLE = True
except ImportError:
WRF_PYTHON_AVAILABLE = False
class Model():
"""
This class stores the model specific parameters for the radar simulator.
Attributes
----------
Rho_hyd: dict
A dictionary whose keys are the names of the model's hydrometeor classes and
whose values are the density of said hydrometeors in :math:`kg\ m^{-3}`
fluffy: dict
A dictionary whose keys are the names of the model's ice hydrometeor classes and
whose values are the ice fluffiness factor for the fwd calculations using r_e,
where values of 0 - equal volume sphere, 1 - fluffy sphere i.e., diameter = maximum dimension.
lidar_ratio: dict
A dictionary whose keys are the names of the model's hydrometeor classes and
whose values are the lidar_ratio of said hydrometeors.
vel_param_a: dict
A dictionary whose keys are the names of the model's hydrometeor classes and
whose values are the :math:`a` parameters to the equation :math:`V = aD^b` used to
calculate terminal velocity corresponding to each hydrometeor.
vel_param_b: dict
A dictionary whose keys are the names of the model's hydrometeor classes and
whose values are the :math:`b` parameters to the equation :math:`V = aD^b` used to
calculate terminal velocity corresponding to each hydrometeor.
N_field: dict
A dictionary whose keys are the names of the model's hydrometeor classes and
whose values are the number concentrations in :math:`cm^{-3}` corresponding to
each hydrometeor class.
T_field: str
A string containing the name of the temperature field in the model.
q_field: str
A string containing the name of the water vapor mixing ratio field (in kg/kg) in the model.
p_field: str
A string containing the name of the pressure field (in mbar) in the model.
z_field: str
A string containing the name of the height field (in m) in the model.
conv_frac_names: dict
A dictionary containing the names of the convective fraction corresponding to each
hydrometeor class in the model.
strat_frac_names: dict
A dictionary containing the names of the stratiform fraction corresponding to each
hydrometeor class in the model.
conv_frac_names_for_rad: dict
A dictionary containing the names of the convective fraction corresponding to each
hydrometeor class in the model for the radiation scheme.
strat_frac_names_for_rad: dict
A dictionary containing the names of the stratiform fraction corresponding to each
hydrometeor class in the model for the radiation scheme.
conv_re_fields: dict
A dictionary containing the names of the effective radii of each convective
hydrometeor class
strat_re_fields: dict
A dictionary containing the names of the effective radii of each stratiform
hydrometeor class
time_dim: str
The name of the time dimension in the model.
height_dim: str
The name of the height dimension in the model.
model_name: str
The name of the model (used for plotting).
x_dim: str
The name of the x dimension of the model.
y_dim: str
The name of the y dimension of the model.
"""
def __init__(self):
self.Rho_hyd = {}
self.fluffy = {}
self.lidar_ratio = {}
self.LDR_per_hyd = {}
self.vel_param_a = {}
self.vel_param_b = {}
self.q_names_convective = {}
self.q_names_stratiform = {}
self.N_field = {}
self.T_field = ""
self.q_field = ""
self.p_field = ""
self.z_field = ""
self.qp_field = {}
self.conv_frac_names = {}
self.strat_frac_names = {}
self.conv_frac_names_for_rad = {}
self.strat_frac_names_for_rad = {}
self.conv_re_fields = {}
self.strat_re_fields = {}
self.ds = None
self.time_dim = "time"
self.height_dim = "height"
self.model_name = "empty_model"
self.x_dim = None
self.y_dim = None
self.lat_name = None
self.lon_name = None
self.consts = {"c": 299792458.0, # m/s
"R_d": 287.058, # J K^-1 Kg^-1
"g": 9.80665, # m/s^2
"Avogadro_c": 6.022140857e23,
"R": 8.3144598} # J K^-1 mol^-1
def _add_vel_units(self):
for my_keys in self.vel_param_a.keys():
self.vel_param_a[my_keys] = self.vel_param_a[my_keys] * (
ureg.meter ** (1 - self.vel_param_b[my_keys].magnitude) / ureg.second)
def _prepare_variables(self):
for variable in self.ds.variables.keys():
attrs = self.ds[variable].attrs
try:
self.ds[variable] = self.ds[variable].astype('float64')
except TypeError:
continue
self.ds[variable].attrs = attrs
def _crop_time_range(self, time_range):
"""
Crop model output time range.
Can significantly cut subcolumn processing time.
Parameters
----------
time_range: tuple, list, or array, typically in datetime64 format
Two-element array with starting and ending of time range.
"""
time_ind = np.logical_and(self.ds[self.time_dim] >= time_range[0],
self.ds[self.time_dim] < time_range[1])
if np.sum(time_ind) == 0:
self.ds.close()
print("The requested time range: {0} to {1} is out of the \
model output range; Ignoring crop request.".format(time_range[0], time_range[1]))
else:
self.ds = self.ds.isel({self.time_dim: time_ind})
@property
def hydrometeor_classes(self):
"""
The list of hydrometeor classes.
"""
return list(self.N_field.keys())
@property
def num_hydrometeor_classes(self):
"""
The number of hydrometeor classes
"""
return len(list(self.N_field.keys()))
@property
def num_subcolumns(self):
"""
Gets the number of subcolumns in the model. Will
return 0 if the number of subcolumns has not yet been set.
"""
if 'subcolumn' in self.ds.dims.keys():
return self.ds.dims['subcolumn']
else:
return 0
@num_subcolumns.setter
def num_subcolumns(self, a):
"""
This will set the number of subcolumns in the simulated radar output.
This is a handy shortcut for setting the number of subcolumns if you
do not want to use any of the functions in the simulator module to
do so.
"""
subcolumn = xr.DataArray(np.arange(a), dims='subcolumn')
self.ds['subcolumn'] = subcolumn
def subcolumns_to_netcdf(self, file_name):
"""
Saves all of the simulated subcolumn parameters to a netCDF file.
Parameters
----------
file_name: str
The name of the file to save to.
"""
# Set all relevant variables to save:
vars_to_keep = ["sub_col", "subcol", "strat_", "conv_", "_tot", "_ext", "_mask", "_min", "mpr", "fpr"]
var_dict = {}
for my_var in self.ds.variables.keys():
if np.any([x in my_var for x in vars_to_keep]):
var_dict[my_var] = self.ds[my_var]
out_ds = xr.Dataset(var_dict)
out_ds.to_netcdf(file_name)
def load_subcolumns_from_netcdf(self, file_name):
"""
Load all of the subcolumn data from a previously saved netCDF file.
The dataset being loaded must match the current number of subcolumns if there are any
generated.
Parameters
----------
file_name: str
Name of the file to save.
"""
my_file = xr.open_dataset(file_name)
self.ds = xr.merge([self.ds, my_file])
my_file.close()
class ModelE(Model):
def __init__(self, file_path, time_range=None):
"""
This loads a ModelE simulation with all of the necessary parameters for EMC^2 to run.
Parameters
----------
file_path: str
Path to a ModelE simulation.
"""
super().__init__()
self.Rho_hyd = {'cl': 1000. * ureg.kg / (ureg.m**3), 'ci': 500. * ureg.kg / (ureg.m**3),
'pl': 1000. * ureg.kg / (ureg.m**3), 'pi': 250. * ureg.kg / (ureg.m**3)}
self.fluffy = {'ci': 0.5 * ureg.dimensionless, 'pi': 0.5 * ureg.dimensionless}
self.lidar_ratio = {'cl': 18. * ureg.dimensionless,
'ci': 24. * ureg.dimensionless,
'pl': 5.5 * ureg.dimensionless,
'pi': 24.0 * ureg.dimensionless}
self.LDR_per_hyd = {'cl': 0.03 * 1 / (ureg.kg / (ureg.m**3)),
'ci': 0.35 * 1 / (ureg.kg / (ureg.m**3)),
'pl': 0.1 * 1 / (ureg.kg / (ureg.m**3)),
'pi': 0.40 * 1 / (ureg.kg / (ureg.m**3))}
self.vel_param_a = {'cl': 3e-7, 'ci': 700., 'pl': 841.997, 'pi': 11.72}
self.vel_param_b = {'cl': 2. * ureg.dimensionless,
'ci': 1. * ureg.dimensionless,
'pl': 0.8 * ureg.dimensionless,
'pi': 0.41 * ureg.dimensionless}
super()._add_vel_units()
self.q_field = "q"
self.N_field = {'cl': 'ncl', 'ci': 'nci', 'pl': 'npl', 'pi': 'npi'}
self.p_field = "p_3d"
self.z_field = "z"
self.T_field = "t"
self.height_dim = "p"
self.time_dim = "time"
self.conv_frac_names = {'cl': 'cldmccl', 'ci': 'cldmcci', 'pl': 'cldmcpl', 'pi': 'cldmcpi'}
self.strat_frac_names = {'cl': 'cldsscl', 'ci': 'cldssci', 'pl': 'cldsspl', 'pi': 'cldsspi'}
self.conv_frac_names_for_rad = {'cl': 'cldmcr', 'ci': 'cldmcr',
'pl': 'cldmcpl', 'pi': 'cldmcpi'}
self.strat_frac_names_for_rad = {'cl': 'cldssr', 'ci': 'cldssr',
'pl': 'cldssr', 'pi': 'cldssr'}
self.conv_re_fields = {'cl': 're_mccl', 'ci': 're_mcci', 'pi': 're_mcpi', 'pl': 're_mcpl'}
self.strat_re_fields = {'cl': 're_sscl', 'ci': 're_ssci', 'pi': 're_sspi', 'pl': 're_sspl'}
self.q_names_convective = {'cl': 'QCLmc', 'ci': 'QCImc', 'pl': 'QPLmc', 'pi': 'QPImc'}
self.q_names_stratiform = {'cl': 'qcl', 'ci': 'qci', 'pl': 'qpl', 'pi': 'qpi'}
self.ds = read_netcdf(file_path)
# Check to make sure we are loading a single column
if 'lat' in [x for x in self.ds.dims.keys()]:
if self.ds.dims['lat'] != 1 or self.ds.dims['lon'] != 1:
self.ds.close()
raise RuntimeError("%s is not an SCM run. EMC^2 will only work with SCM runs." % file_path)
# No need for lat and lon dimensions
self.ds = self.ds.squeeze(dim=('lat', 'lon'))
# crop specific model output time range (if requested)
if time_range is not None:
if np.issubdtype(time_range.dtype, np.datetime64):
super()._crop_time_range(time_range)
else:
raise RuntimeError("input time range is not in the required datetime64 data type")
# ModelE has pressure units in mb, but pint only supports hPa
self.ds["p_3d"].attrs["units"] = "hPa"
self.model_name = "ModelE"
class E3SM(Model):
def __init__(self, file_path, time_range=None):
"""
This loads an E3SM simulation output with all of the necessary parameters for EMC^2 to run.
Parameters
----------
file_path: str
Path to an E3SM simulation.
"""
super().__init__()
self.Rho_hyd = {'cl': 1000. * ureg.kg / (ureg.m**3), 'ci': 500. * ureg.kg / (ureg.m**3),
'pl': 1000. * ureg.kg / (ureg.m**3), 'pi': 250. * ureg.kg / (ureg.m**3)}
self.fluffy = {'ci': 0.5 * ureg.dimensionless, 'pi': 0.5 * ureg.dimensionless}
self.lidar_ratio = {'cl': 18. * ureg.dimensionless,
'ci': 24. * ureg.dimensionless,
'pl': 5.5 * ureg.dimensionless,
'pi': 24.0 * ureg.dimensionless}
self.LDR_per_hyd = {'cl': 0.03 * 1 / (ureg.kg / (ureg.m**3)),
'ci': 0.35 * 1 / (ureg.kg / (ureg.m**3)),
'pl': 0.1 * 1 / (ureg.kg / (ureg.m**3)),
'pi': 0.40 * 1 / (ureg.kg / (ureg.m**3))}
self.vel_param_a = {'cl': 3e-7, 'ci': 700., 'pl': 841.997, 'pi': 11.72}
self.vel_param_b = {'cl': 2. * ureg.dimensionless,
'ci': 1. * ureg.dimensionless,
'pl': 0.8 * ureg.dimensionless,
'pi': 0.41 * ureg.dimensionless}
super()._add_vel_units()
self.q_field = "Q"
self.N_field = {'cl': 'NUMLIQ', 'ci': 'NUMICE', 'pl': 'NUMRAI', 'pi': 'NUMSNO'}
self.p_field = "p_3d"
self.z_field = "Z3"
self.T_field = "T"
self.height_dim = "lev"
self.time_dim = "ncol"
self.conv_frac_names = {'cl': 'zeros_cf', 'ci': 'zeros_cf', 'pl': 'zeros_cf', 'pi': 'zeros_cf'}
self.strat_frac_names = {'cl': 'CLOUD', 'ci': 'CLOUD', 'pl': 'CLOUD', 'pi': 'CLOUD'}
self.conv_frac_names_for_rad = {'cl': 'zeros_cf', 'ci': 'zeros_cf',
'pl': 'zeros_cf', 'pi': 'zeros_cf'}
self.strat_frac_names_for_rad = {'cl': 'CLOUD', 'ci': 'CLOUD',
'pl': 'CLOUD', 'pi': 'CLOUD'}
self.conv_re_fields = {'cl': 'zeros_cf', 'ci': 'zeros_cf', 'pi': 'zeros_cf', 'pl': 'zeros_cf'}
self.strat_re_fields = {'cl': 'AREL', 'ci': 'AREI', 'pi': 'ADSNOW', 'pl': 'ADRAIN'}
self.q_names_convective = {'cl': 'zeros_cf', 'ci': 'zeros_cf', 'pl': 'zeros_cf', 'pi': 'zeros_cf'}
self.q_names_stratiform = {'cl': 'CLDLIQ', 'ci': 'CLDICE', 'pl': 'RAINQM', 'pi': 'SNOWQM'}
self.ds = read_netcdf(file_path)
# Check to make sure we are loading a single column
if 'lat' in [x for x in self.ds.dims.keys()]:
if self.ds.dims['lat'] != 1 or self.ds.dims['lon'] != 1:
self.ds.close()
raise RuntimeError("%s is not a column dataset. EMC^2 will currently works with column data." %
file_path)
# No need for lat and lon dimensions
self.ds = self.ds.squeeze(dim=('lat', 'lon'))
# crop specific model output time range (if requested)
if time_range is not None:
if np.issubdtype(time_range.dtype, np.datetime64):
super()._crop_time_range(time_range)
else:
raise RuntimeError("input time range is not in the required datetime64 data type")
self.ds[self.p_field] = (self.ds["P0"] * self.ds["hyam"] + self.ds["PS"] * self.ds["hybm"]).T / 1e2 # hPa
self.ds[self.p_field].attrs["units"] = "hPa"
self.ds["zeros_cf"] = xr.DataArray( | np.zeros_like(self.ds[self.p_field].values) | numpy.zeros_like |
import numpy as np
from prml.linear.classifier import Classifier
from prml.rv.gaussian import Gaussian
class LinearDiscriminantAnalyzer(Classifier):
"""
Linear discriminant analysis model
"""
def _fit(self, X, t, clip_min_norm=1e-10):
self._check_input(X)
self._check_target(t)
self._check_binary(t)
X0 = X[t == 0]
X1 = X[t == 1]
m0 = | np.mean(X0, axis=0) | numpy.mean |
# Copyright 2020 Q-CTRL Pty Ltd & Q-CTRL Inc
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
========================
Tests for Predefined DDS
========================
"""
import numpy as np
import pytest
from qctrlopencontrols import new_predefined_dds
from qctrlopencontrols.dynamic_decoupling_sequences import (
CARR_PURCELL,
CARR_PURCELL_MEIBOOM_GILL,
PERIODIC_SINGLE_AXIS,
QUADRATIC,
SPIN_ECHO,
UHRIG_SINGLE_AXIS,
WALSH_SINGLE_AXIS,
X_CONCATENATED,
XY_CONCATENATED,
)
from qctrlopencontrols.exceptions import ArgumentsValueError
SIGMA_X = np.array([[0.0, 1.0], [1.0, 0.0]])
SIGMA_Y = np.array([[0.0, -1.0j], [1.0j, 0.0]])
SIGMA_Z = np.array([[1.0, 0.0], [0.0, -1.0]])
def test_ramsey():
"""Tests Ramsey sequence
"""
duration = 10.0
sequence = new_predefined_dds(scheme="Ramsey", duration=duration)
_offsets = np.array([])
_rabi_rotations = np.array([])
_azimuthal_angles = np.array([])
_detuning_rotations = np.array([])
assert np.allclose(_offsets, sequence.offsets)
assert np.allclose(_rabi_rotations, sequence.rabi_rotations)
assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles)
assert np.allclose(_detuning_rotations, sequence.detuning_rotations)
sequence = new_predefined_dds(
scheme="Ramsey", duration=duration, pre_post_rotation=True
)
_rabi_rotations = np.array([np.pi / 2, np.pi / 2])
_azimuthal_angles = np.array([0.0, np.pi])
_detuning_rotations = np.array([0.0, 0.0])
assert np.allclose(_rabi_rotations, sequence.rabi_rotations)
assert | np.allclose(_azimuthal_angles, sequence.azimuthal_angles) | numpy.allclose |
import sys
sys.path.insert(0, "../")
from PINN_Survey.problems.burgers.v1 import Burgers, Burgers_Siren, Burgers_Random_Fourier
from PINN_Survey.problems.burgers.data.load import load_burgers_bounds
from PINN_Survey.problems.helmholtz.data.load import load_helmholtz_bounds
from PINN_Survey.problems.helmholtz.v1 import Helmholtz, Helmholtz_Siren, Helmholtz_Random_Fourier
from PINN_Base.util import bounds_from_data, random_choice
import numpy as np
import tensorflow as tf
def rmsprop_init_optimizers(self):
self.optimizer_RMSProp = tf.train.RMSPropOptimizer(
learning_rate=.001).minimize(self.loss)
def rmsprop_train(self, X, U, X_df, batch_size, epochs):
self._train_stochastic_optimizer(
self.optimizer_RMSProp, X, U, X_df, batch_size, epochs)
class Burgers_Base_RMSProp(Burgers):
def _init_optimizers(self):
rmsprop_init_optimizers(self)
def train_RMSProp_batched(self, X, U, X_df, batch_size, epochs):
rmsprop_train(self, X, U, X_df, batch_size, epochs)
class Helmholtz_Base_RMSProp(Helmholtz):
def _init_optimizers(self):
rmsprop_init_optimizers(self)
def train_RMSProp_batched(self, X, U, X_df, batch_size, epochs):
rmsprop_train(self, X, U, X_df, batch_size, epochs)
MAX_THREADS = 32
config = tf.ConfigProto(
intra_op_parallelism_threads=MAX_THREADS
)
def burgers_big_adam():
X_true, U_true, X_bounds, U_bounds, _ = load_burgers_bounds()
X = np.vstack(X_bounds)
U = np.vstack(U_bounds)
X_df = random_choice(X_true)
lower_bound, upper_bound = bounds_from_data(X_true)
layers = [2, 256, 256, 256, 256, 256, 1]
nu = .01 / np.pi
model = Burgers(
lower_bound, upper_bound, layers, nu, session_config=config, use_collocation_residual=False)
model.train_Adam_batched(X, U, X_df, batch_size=64, epochs=50000)
U_hat = model.predict(X_true)
rel_error = np.linalg.norm(U_true - U_hat, 2) / np.linalg.norm(U_true, 2)
print(rel_error)
with open("big_log.csv", "a+") as f:
f.write(f"burgers,adam,{rel_error}\n")
def burgers_big_rmsprop():
X_true, U_true, X_bounds, U_bounds, _ = load_burgers_bounds()
X = np.vstack(X_bounds)
U = np.vstack(U_bounds)
X_df = random_choice(X_true)
lower_bound, upper_bound = bounds_from_data(X_true)
layers = [2, 256, 256, 256, 256, 256, 1]
nu = .01 / np.pi
model = Burgers_Base_RMSProp(
lower_bound, upper_bound, layers, nu, session_config=config, use_collocation_residual=False)
model.train_RMSProp_batched(X, U, X_df, batch_size=64, epochs=50000)
U_hat = model.predict(X_true)
rel_error = np.linalg.norm(U_true - U_hat, 2) / np.linalg.norm(U_true, 2)
print(rel_error)
with open("big_log.csv", "a+") as f:
f.write(f"burgers,rms,{rel_error}\n")
def burgers_big_siren():
X_true, U_true, X_bounds, U_bounds, _ = load_burgers_bounds()
X = np.vstack(X_bounds)
U = np.vstack(U_bounds)
X_df = random_choice(X_true)
lower_bound, upper_bound = bounds_from_data(X_true)
layers = [2, 256, 256, 256, 256, 256, 1]
nu = .01 / np.pi
model = Burgers_Siren(
lower_bound, upper_bound, layers, nu, session_config=config, use_collocation_residual=False)
model.train_Adam_batched(X, U, X_df, batch_size=64, epochs=50000)
U_hat = model.predict(X_true)
rel_error = np.linalg.norm(U_true - U_hat, 2) / np.linalg.norm(U_true, 2)
print(rel_error)
with open("big_log.csv", "a+") as f:
f.write(f"burgers_siren,Adam,{rel_error}\n")
def burgers_big_rf():
X_true, U_true, X_bounds, U_bounds, _ = load_burgers_bounds()
X = np.vstack(X_bounds)
U = np.vstack(U_bounds)
X_df = random_choice(X_true)
lower_bound, upper_bound = bounds_from_data(X_true)
layers = [2, 256, 256, 256, 256, 256, 1]
nu = .01 / np.pi
model = Burgers_Random_Fourier(
lower_bound, upper_bound, layers, nu, session_config=config, use_collocation_residual=False)
model.train_Adam_batched(X, U, X_df, batch_size=64, epochs=50000)
U_hat = model.predict(X_true)
rel_error = np.linalg.norm(U_true - U_hat, 2) / np.linalg.norm(U_true, 2)
print(rel_error)
with open("big_log.csv", "a+") as f:
f.write(f"burgers_rf,Adam,{rel_error}\n")
def helmholtz_big_adam():
X_true, U_true, X_bounds, U_bounds, _ = load_helmholtz_bounds()
X = np.vstack(X_bounds)
U = np.vstack(U_bounds)
X_df = random_choice(X_true)
lower_bound, upper_bound = bounds_from_data(X_true)
layers = [2, 256, 256, 256, 256, 256, 1]
a = 1
b = 4
model = Helmholtz(
lower_bound, upper_bound, layers, a, b, session_config=config, use_collocation_residual=False, df_multiplier=1e-2)
model.train_Adam_batched(X, U, X_df, batch_size=64, epochs=50000)
U_hat = model.predict(X_true)
rel_error = np.linalg.norm(U_true - U_hat, 2) / np.linalg.norm(U_true, 2)
print(rel_error)
with open("big_log.csv", "a+") as f:
f.write(f"helmholtz,adam,{rel_error}\n")
def helmholtz_big_rmsprop():
X_true, U_true, X_bounds, U_bounds, _ = load_helmholtz_bounds()
X = np.vstack(X_bounds)
U = np.vstack(U_bounds)
X_df = random_choice(X_true)
lower_bound, upper_bound = bounds_from_data(X_true)
layers = [2, 256, 256, 256, 256, 256, 1]
a = 1
b = 4
model = Helmholtz_Base_RMSProp(
lower_bound, upper_bound, layers, a, b, session_config=config, use_collocation_residual=False, df_multiplier=1e-2)
model.train_RMSProp_batched(X, U, X_df, batch_size=64, epochs=50000)
U_hat = model.predict(X_true)
rel_error = np.linalg.norm(U_true - U_hat, 2) / np.linalg.norm(U_true, 2)
print(rel_error)
with open("big_log.csv", "a+") as f:
f.write(f"helmholtz,rms,{rel_error}\n")
def helmholtz_big_siren():
X_true, U_true, X_bounds, U_bounds, _ = load_helmholtz_bounds()
X = np.vstack(X_bounds)
U = np.vstack(U_bounds)
X_df = random_choice(X_true)
lower_bound, upper_bound = bounds_from_data(X_true)
layers = [2, 256, 256, 256, 256, 256, 1]
a = 1
b = 4
model = Helmholtz_Siren(
lower_bound, upper_bound, layers, a, b, session_config=config, use_collocation_residual=False, df_multiplier=1e-2)
model.train_Adam_batched(X, U, X_df, batch_size=64, epochs=50000)
U_hat = model.predict(X_true)
rel_error = np.linalg.norm(U_true - U_hat, 2) / np.linalg.norm(U_true, 2)
print(rel_error)
with open("big_log.csv", "a+") as f:
f.write(f"helmholtz_siren,Adam,{rel_error}\n")
def helmholtz_big_rf():
X_true, U_true, X_bounds, U_bounds, _ = load_helmholtz_bounds()
X = np.vstack(X_bounds)
U = np.vstack(U_bounds)
X_df = random_choice(X_true)
lower_bound, upper_bound = bounds_from_data(X_true)
layers = [2, 256, 256, 256, 256, 256, 1]
a = 1
b = 4
model = Helmholtz_Random_Fourier(
lower_bound, upper_bound, layers, a, b, session_config=config, use_collocation_residual=False, df_multiplier=1e-2)
model.train_Adam_batched(X, U, X_df, batch_size=64, epochs=50000)
U_hat = model.predict(X_true)
rel_error = np.linalg.norm(U_true - U_hat, 2) / | np.linalg.norm(U_true, 2) | numpy.linalg.norm |
# Copyright 2020 AstroLab Software
# Author: <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import healpy as hp
import numpy as np
import pandas as pd
import gzip
import io
from astropy.io import fits
from astroquery.mpc import MPC
from astropy.convolution import convolve as astropy_convolve
from astropy.convolution import Gaussian2DKernel
from astropy.convolution import Box2DKernel
from astropy.coordinates import SkyCoord, get_constellation
from astropy.visualization import AsymmetricPercentileInterval, simple_norm
from astropy.time import Time
hbase_type_converter = {
'integer': int,
'long': int,
'float': float,
'double': float,
'string': str,
'fits/image': str
}
def format_hbase_output(
hbase_output, schema_client,
group_alerts: bool, truncated: bool = False,
extract_color: bool = True, with_constellation: bool = True):
"""
"""
if hbase_output.isEmpty():
return pd.DataFrame({})
# Construct the dataframe
pdfs = pd.DataFrame.from_dict(hbase_output, orient='index')
if 'd:knscore' not in pdfs.columns:
pdfs['d:knscore'] = np.zeros(len(pdfs), dtype=float)
# Remove hbase specific fields
if 'key:key' in pdfs.columns or 'key:time' in pdfs.columns:
pdfs = pdfs.drop(columns=['key:key', 'key:time'])
# Type conversion
pdfs = pdfs.astype(
{i: hbase_type_converter[schema_client.type(i)] for i in pdfs.columns})
if not truncated:
# Fink final classification
classifications = extract_fink_classification(
pdfs['d:cdsxmatch'],
pdfs['d:roid'],
pdfs['d:mulens_class_1'],
pdfs['d:mulens_class_2'],
pdfs['d:snn_snia_vs_nonia'],
pdfs['d:snn_sn_vs_all'],
pdfs['d:rfscore'],
pdfs['i:ndethist'],
pdfs['i:drb'],
pdfs['i:classtar'],
pdfs['i:jd'],
pdfs['i:jdstarthist'],
pdfs['d:knscore']
)
pdfs['v:classification'] = classifications
if extract_color:
# Extract color evolution
pdfs = pdfs.sort_values('i:objectId')
pdfs['v:g-r'] = extract_last_g_minus_r_each_object(pdfs, kind='last')
pdfs['v:rate(g-r)'] = extract_last_g_minus_r_each_object(pdfs, kind='rate')
pdfs = pdfs.sort_values('i:jd', ascending=False)
pdfs['v:dg'], pdfs['v:rate(dg)'] = extract_delta_color(pdfs, filter_=1)
pdfs['v:dr'], pdfs['v:rate(dr)'] = extract_delta_color(pdfs, filter_=2)
# Human readable time
pdfs['v:lastdate'] = pdfs['i:jd'].apply(convert_jd)
if with_constellation:
coords = SkyCoord(
pdfs['i:ra'],
pdfs['i:dec'],
unit='deg'
)
constellations = get_constellation(coords)
pdfs['v:constellation'] = constellations
# Display only the last alert
if group_alerts:
pdfs['i:jd'] = pdfs['i:jd'].astype(float)
pdfs = pdfs.loc[pdfs.groupby('i:objectId')['i:jd'].idxmax()]
# sort values by time
pdfs = pdfs.sort_values('i:jd', ascending=False)
return pdfs
def isoify_time(t):
try:
tt = Time(t)
except ValueError as e:
ft = float(t)
if ft // 2400000:
tt = Time(ft, format='jd')
else:
tt = Time(ft, format='mjd')
return tt.iso
def markdownify_objectid(objectid):
"""
"""
objectid_markdown = '[{}](/{})'.format(
objectid,
objectid
)
return objectid_markdown
def validate_query(query, query_type):
""" Validate a query. Need to be rewritten in a better way.
"""
empty_query_type = (query_type is None) or (query_type == '')
if empty_query_type:
# This can only happen in queries formed from URL parameters
header = "Empty query type"
text = "You need to specify a query_type in your request (e.g. ?query_type=Conesearch&ra=value&dec=value&radius=value)"
return {'flag': False, 'header': header, 'text': text}
empty_query = (query is None) or (query == '')
# no queries
if empty_query and ((query_type == 'objectID') or (query_type == 'Conesearch') or (query_type == 'Date')):
header = "Empty query"
text = "You need to choose a query type and fill the search bar"
return {'flag': False, 'header': header, 'text': text}
# bad objectId
bad_objectid = (query_type == 'objectID') and not (query.startswith('ZTF'))
if bad_objectid:
header = "Bad ZTF object ID"
text = "ZTF object ID must start with `ZTF`"
return {'flag': False, 'header': header, 'text': text}
# bad conesearch
lenquery = len(query.split(','))
bad_conesearch = (query_type == 'Conesearch') and not ((lenquery == 3) or (lenquery == 5))
if bad_conesearch:
header = "Bad Conesearch formula"
text = "Conesearch must contain comma-separated RA, Dec, radius or RA, Dec, radius, startdate, window. See Help for more information."
return {'flag': False, 'header': header, 'text': text}
# bad search date
if query_type == 'Date':
try:
_ = isoify_time(query)
except (ValueError, TypeError) as e:
header = 'Bad start time'
return {'flag': False, 'header': header, 'text': str(e)}
return {'flag': True, 'header': 'Good query', 'text': 'Well done'}
def extract_row(key: str, clientresult) -> dict:
""" Extract one row from the client result, and return result as dict
"""
data = clientresult[key]
return dict(data)
def readstamp(stamp: str, return_type='array') -> np.array:
""" Read the stamp data inside an alert.
Parameters
----------
alert: dictionary
dictionary containing alert data
field: string
Name of the stamps: cutoutScience, cutoutTemplate, cutoutDifference
return_type: str
Data block of HDU 0 (`array`) or original FITS uncompressed (`FITS`) as file-object.
Default is `array`.
Returns
----------
data: np.array
2D array containing image data (`array`) or FITS file uncompressed as file-object (`FITS`)
"""
with gzip.open(io.BytesIO(stamp), 'rb') as f:
with fits.open(io.BytesIO(f.read())) as hdul:
if return_type == 'array':
data = hdul[0].data
elif return_type == 'FITS':
data = io.BytesIO()
hdul.writeto(data)
data.seek(0)
return data
def extract_cutouts(pdf: pd.DataFrame, client, col=None, return_type='array') -> pd.DataFrame:
""" Query and uncompress cutout data from the HBase table
Inplace modifications
Parameters
----------
pdf: Pandas DataFrame
DataFrame returned by `format_hbase_output` (see api.py)
client: com.Lomikel.HBaser.HBaseClient
HBase client used to query the database
col: str
Name of the cutouts to be downloaded (e.g. b:cutoutScience_stampData). If None, return all 3
return_type: str
array or original gzipped FITS
Returns
----------
pdf: Pandas DataFrame
Modified original DataFrame with cutout data uncompressed (2D array)
"""
if col is not None:
cols = ['b:cutoutScience_stampData', 'b:cutoutTemplate_stampData', 'b:cutoutDifference_stampData']
assert col in cols
pdf[col] = pdf[col].apply(
lambda x: readstamp(client.repository().get(x), return_type=return_type)
)
return pdf
if 'b:cutoutScience_stampData' not in pdf.columns:
pdf['b:cutoutScience_stampData'] = 'binary:' + pdf['i:objectId'] + '_' + pdf['i:jd'].astype('str') + ':cutoutScience_stampData'
pdf['b:cutoutTemplate_stampData'] = 'binary:' + pdf['i:objectId'] + '_' + pdf['i:jd'].astype('str') + ':cutoutTemplate_stampData'
pdf['b:cutoutDifference_stampData'] = 'binary:' + pdf['i:objectId'] + '_' + pdf['i:jd'].astype('str') + ':cutoutDifference_stampData'
pdf['b:cutoutScience_stampData'] = pdf['b:cutoutScience_stampData'].apply(
lambda x: readstamp(client.repository().get(x), return_type=return_type)
)
pdf['b:cutoutTemplate_stampData'] = pdf['b:cutoutTemplate_stampData'].apply(
lambda x: readstamp(client.repository().get(x), return_type=return_type)
)
pdf['b:cutoutDifference_stampData'] = pdf['b:cutoutDifference_stampData'].apply(
lambda x: readstamp(client.repository().get(x), return_type=return_type)
)
return pdf
def extract_properties(data: str, fieldnames: list):
"""
"""
pdfs = pd.DataFrame.from_dict(data, orient='index')
if fieldnames is not None:
return pdfs[fieldnames]
else:
return pdfs
def extract_fink_classification_single(data):
"""
"""
if data is None:
return 'Error'
pdf = extract_properties(
data,
[
'i:jd',
'd:cdsxmatch',
'd:mulens_class_1',
'd:mulens_class_2',
'd:roid',
'd:snn_sn_vs_all',
'd:snn_snia_vs_nonia',
'd:rfscore',
'i:ndethist',
'i:drb',
'i:classtar',
'i:jd',
'i:jdstarthist',
'd:knscore'
]
)
pdf = pdf.sort_values('i:jd', ascending=False)
classification = extract_fink_classification(
pdf['d:cdsxmatch'],
pdf['d:roid'],
pdf['d:mulens_class_1'],
pdf['d:mulens_class_2'],
pdf['d:snn_snia_vs_nonia'],
pdf['d:snn_sn_vs_all'],
pdf['d:rfscore'],
pdf['i:ndethist'],
pdf['i:drb'],
pdf['i:classtar'],
pdfs['i:jd'],
pdfs['i:jdstarthist'],
pdfs['d:knscore']
)
return classification[0]
def extract_fink_classification(
cdsxmatch, roid, mulens_class_1, mulens_class_2,
snn_snia_vs_nonia, snn_sn_vs_all, rfscore,
ndethist, drb, classtar, jd, jdstarthist, knscore_):
""" Extract the classification of an alert based on module outputs
See https://arxiv.org/abs/2009.10185 for more information
"""
classification = pd.Series(['Unknown'] * len(cdsxmatch))
ambiguity = pd.Series([0] * len(cdsxmatch))
# Microlensing classification
medium_ndethist = ndethist.astype(int) < 100
f_mulens = (mulens_class_1 == 'ML') & (mulens_class_2 == 'ML') & medium_ndethist
# SN Ia
snn1 = snn_snia_vs_nonia.astype(float) > 0.5
snn2 = snn_sn_vs_all.astype(float) > 0.5
active_learn = rfscore.astype(float) > 0.5
# KN
high_knscore = knscore_.astype(float) > 0.5
# Others
# Note jdstarthist is not really reliable...
# see https://github.com/astrolabsoftware/fink-science-portal/issues/163
# KN & SN candidate still affected (not Early SN Ia candidate)
# Perhaps something to report to ZTF
sn_history = jd.astype(float) - jdstarthist.astype(float) <= 90
new_detection = jd.astype(float) - jdstarthist.astype(float) < 20
high_drb = drb.astype(float) > 0.5
high_classtar = classtar.astype(float) > 0.4
early_ndethist = ndethist.astype(int) < 20
no_mpc = roid.astype(int) != 3
no_first_det = ndethist.astype(int) > 1
list_simbad_galaxies = [
"galaxy",
"Galaxy",
"EmG",
"Seyfert",
"Seyfert_1",
"Seyfert_2",
"BlueCompG",
"StarburstG",
"LSB_G",
"HII_G",
"High_z_G",
"GinPair",
"GinGroup",
"BClG",
"GinCl",
"PartofG",
]
keep_cds = \
["Unknown", "Candidate_SN*", "SN", "Transient", "Fail"] + list_simbad_galaxies
base_sn = (snn1 | snn2) & cdsxmatch.isin(keep_cds) & high_drb & high_classtar & no_mpc & no_first_det
f_sn = base_sn & sn_history
f_sn_early = base_sn & early_ndethist & active_learn
# Kilonova
keep_cds = \
["Unknown", "Transient", "Fail"] + list_simbad_galaxies
f_kn = high_knscore & high_drb & high_classtar & new_detection
f_kn = f_kn & early_ndethist & cdsxmatch.isin(keep_cds)
# Solar System Objects
f_roid_2 = roid.astype(int) == 2
f_roid_3 = roid.astype(int) == 3
# Simbad xmatch
f_simbad = ~cdsxmatch.isin(['Unknown', 'Transient', 'Fail'])
classification.mask(f_mulens.values, 'Microlensing candidate', inplace=True)
classification.mask(f_sn.values, 'SN candidate', inplace=True)
classification.mask(f_sn_early.values, 'Early SN Ia candidate', inplace=True)
classification.mask(f_kn.values, 'Kilonova candidate', inplace=True)
classification.mask(f_roid_2.values, 'Solar System candidate', inplace=True)
classification.mask(f_roid_3.values, 'Solar System MPC', inplace=True)
# If several flags are up, we cannot rely on the classification
ambiguity[f_mulens.values] += 1
ambiguity[f_sn.values] += 1
ambiguity[f_roid_2.values] += 1
ambiguity[f_roid_3.values] += 1
f_ambiguity = ambiguity > 1
classification.mask(f_ambiguity.values, 'Ambiguous', inplace=True)
classification = np.where(f_simbad, cdsxmatch, classification)
return classification
def convert_jd(jd, to='iso'):
""" Convert Julian Date into ISO date (UTC).
"""
return Time(jd, format='jd').to_value(to)
def convolve(image, smooth=3, kernel='gauss'):
""" Convolve 2D image. Hacked from aplpy
"""
if smooth is None and isinstance(kernel, str) and kernel in ['box', 'gauss']:
return image
if smooth is not None and not np.isscalar(smooth):
raise ValueError("smooth= should be an integer - for more complex "
"kernels, pass an array containing the kernel "
"to the kernel= option")
# The Astropy convolution doesn't treat +/-Inf values correctly yet, so we
# convert to NaN here.
image_fixed = np.array(image, dtype=float, copy=True)
image_fixed[np.isinf(image)] = np.nan
if isinstance(kernel, str):
if kernel == 'gauss':
kernel = Gaussian2DKernel(
smooth, x_size=smooth * 5, y_size=smooth * 5)
elif kernel == 'box':
kernel = Box2DKernel(smooth, x_size=smooth * 5, y_size=smooth * 5)
else:
raise ValueError("Unknown kernel: {0}".format(kernel))
return astropy_convolve(image, kernel, boundary='extend')
def _data_stretch(
image, vmin=None, vmax=None, pmin=0.25, pmax=99.75,
stretch='linear', vmid: float = 10, exponent=2):
""" Hacked from aplpy
"""
if vmin is None or vmax is None:
interval = AsymmetricPercentileInterval(pmin, pmax, n_samples=10000)
try:
vmin_auto, vmax_auto = interval.get_limits(image)
except IndexError: # no valid values
vmin_auto = vmax_auto = 0
if vmin is None:
#log.info("vmin = %10.3e (auto)" % vmin_auto)
vmin = vmin_auto
else:
pass
#log.info("vmin = %10.3e" % vmin)
if vmax is None:
#log.info("vmax = %10.3e (auto)" % vmax_auto)
vmax = vmax_auto
else:
pass
#log.info("vmax = %10.3e" % vmax)
if stretch == 'arcsinh':
stretch = 'asinh'
normalizer = simple_norm(
image, stretch=stretch, power=exponent,
asinh_a=vmid, min_cut=vmin, max_cut=vmax, clip=False)
data = normalizer(image, clip=True).filled(0)
data = np.nan_to_num(data)
#data = np.clip(data * 255., 0., 255.)
return data#.astype(np.uint8)
def mag2fluxcal_snana(magpsf: float, sigmapsf: float):
""" Conversion from magnitude to Fluxcal from SNANA manual
Parameters
----------
magpsf: float
PSF-fit magnitude from ZTF
sigmapsf: float
Returns
----------
fluxcal: float
Flux cal as used by SNANA
fluxcal_err: float
Absolute error on fluxcal (the derivative has a minus sign)
"""
if magpsf is None:
return None, None
fluxcal = 10 ** (-0.4 * magpsf) * 10 ** (11)
fluxcal_err = 9.21034 * 10 ** 10 * np.exp(-0.921034 * magpsf) * sigmapsf
return fluxcal, fluxcal_err
def apparent_flux(fid, magpsf, sigmapsf, magnr, sigmagnr, magzpsci, isdiffpos):
""" Compute apparent flux from difference magnitude supplied by ZTF
This was heavily influenced by the computation provided by Lasair:
https://github.com/lsst-uk/lasair/blob/master/src/alert_stream_ztf/common/mag.py
Paramters
---------
fid
filter, 1 for green and 2 for red
magpsf,sigmapsf; floats
magnitude from PSF-fit photometry, and 1-sigma error
magnr,sigmagnr: floats
magnitude of nearest source in reference image PSF-catalog
within 30 arcsec and 1-sigma error
magzpsci: float
Magnitude zero point for photometry estimates
isdiffpos: str
t or 1 => candidate is from positive (sci minus ref) subtraction;
f or 0 => candidate is from negative (ref minus sci) subtraction
Returns
--------
dc_flux: float
Apparent magnitude
dc_sigflux: float
Error on apparent magnitude
"""
if magpsf is None:
return None, None
# zero points. Looks like they are fixed.
ref_zps = {1: 26.325, 2: 26.275, 3: 25.660}
magzpref = ref_zps[fid]
# reference flux and its error
magdiff = magzpref - magnr
if magdiff > 12.0:
magdiff = 12.0
ref_flux = 10**(0.4 * magdiff)
ref_sigflux = (sigmagnr / 1.0857) * ref_flux
# difference flux and its error
if magzpsci == 0.0:
magzpsci = magzpref
magdiff = magzpsci - magpsf
if magdiff > 12.0:
magdiff = 12.0
difference_flux = 10**(0.4 * magdiff)
difference_sigflux = (sigmapsf / 1.0857) * difference_flux
# add or subract difference flux based on isdiffpos
if isdiffpos == 't':
dc_flux = ref_flux + difference_flux
else:
dc_flux = ref_flux - difference_flux
# assumes errors are independent. Maybe too conservative.
dc_sigflux = np.sqrt(difference_sigflux**2 + ref_sigflux**2)
return dc_flux, dc_sigflux
def dc_mag(fid, magpsf, sigmapsf, magnr, sigmagnr, magzpsci, isdiffpos):
""" Compute apparent magnitude from difference magnitude supplied by ZTF
Parameters
Stolen from Lasair.
----------
fid
filter, 1 for green and 2 for red
magpsf,sigmapsf
magnitude from PSF-fit photometry, and 1-sigma error
magnr,sigmagnr
magnitude of nearest source in reference image PSF-catalog
within 30 arcsec and 1-sigma error
magzpsci
Magnitude zero point for photometry estimates
isdiffpos
t or 1 => candidate is from positive (sci minus ref) subtraction;
f or 0 => candidate is from negative (ref minus sci) subtraction
"""
# zero points. Looks like they are fixed.
ref_zps = {1: 26.325, 2: 26.275, 3: 25.660}
magzpref = ref_zps[fid]
# difference flux and its error
if magzpsci is None:
magzpsci = magzpref
dc_flux, dc_sigflux = apparent_flux(
fid, magpsf, sigmapsf, magnr, sigmagnr, magzpsci, isdiffpos
)
# apparent mag and its error from fluxes
if (dc_flux == dc_flux) and dc_flux > 0.0:
dc_mag = magzpsci - 2.5 * np.log10(dc_flux)
dc_sigmag = dc_sigflux / dc_flux * 1.0857
else:
dc_mag = magzpsci
dc_sigmag = sigmapsf
return dc_mag, dc_sigmag
def g_minus_r(fid, mag):
""" Compute r-g based on vectors of filters and magnitudes
"""
if len(fid) == 2:
# +1 if [g, r]
# -1 if [r, g]
sign = np.diff(fid)[0]
else:
# last measurement
last_fid = fid[-1]
# last measurement with different filter
# could take the mean
index_other = np.where( | np.array(fid) | numpy.array |
import numpy as np
import os
import re
import requests
import sys
import time
from netCDF4 import Dataset
import pandas as pd
from bs4 import BeautifulSoup
from tqdm import tqdm
# setup constants used to access the data from the different M2M interfaces
BASE_URL = 'https://ooinet.oceanobservatories.org/api/m2m/' # base M2M URL
SENSOR_URL = '12576/sensor/inv/' # Sensor Information
# setup access credentials
AUTH = ['OOIAPI-853A3LA6QI3L62', '<KEY>']
def M2M_Call(uframe_dataset_name, start_date, end_date):
options = '?beginDT=' + start_date + '&endDT=' + end_date + '&format=application/netcdf'
r = requests.get(BASE_URL + SENSOR_URL + uframe_dataset_name + options, auth=(AUTH[0], AUTH[1]))
if r.status_code == requests.codes.ok:
data = r.json()
else:
return None
# wait until the request is completed
print('Waiting for OOINet to process and prepare data request, this may take up to 20 minutes')
url = [url for url in data['allURLs'] if re.match(r'.*async_results.*', url)][0]
check_complete = url + '/status.txt'
with tqdm(total=400, desc='Waiting') as bar:
for i in range(400):
r = requests.get(check_complete)
bar.update(1)
if r.status_code == requests.codes.ok:
bar.n = 400
bar.last_print_n = 400
bar.refresh()
print('\nrequest completed in %f minutes.' % elapsed)
break
else:
time.sleep(3)
elapsed = (i * 3) / 60
return data
def M2M_Files(data, tag=''):
"""
Use a regex tag combined with the results of the M2M data request to collect the data from the THREDDS catalog.
Collected data is gathered into an xarray dataset for further processing.
:param data: JSON object returned from M2M data request with details on where the data is to be found for download
:param tag: regex tag to use in discriminating the data files, so we only collect the correct ones
:return: the collected data as an xarray dataset
"""
# Create a list of the files from the request above using a simple regex as a tag to discriminate the files
url = [url for url in data['allURLs'] if re.match(r'.*thredds.*', url)][0]
files = list_files(url, tag)
return files
def list_files(url, tag=''):
"""
Function to create a list of the NetCDF data files in the THREDDS catalog created by a request to the M2M system.
:param url: URL to user's THREDDS catalog specific to a data request
:param tag: regex pattern used to distinguish files of interest
:return: list of files in the catalog with the URL path set relative to the catalog
"""
page = requests.get(url).text
soup = BeautifulSoup(page, 'html.parser')
pattern = re.compile(tag)
return [node.get('href') for node in soup.find_all('a', text=pattern)]
def M2M_Data(nclist,variables):
thredds = 'https://opendap.oceanobservatories.org/thredds/dodsC/ooi/'
#nclist is going to contain more than one url eventually
for jj in range(len(nclist)):
url=nclist[jj]
url=url[25:]
dap_url = thredds + url + '#fillmismatch'
openFile = Dataset(dap_url,'r')
for ii in range(len(variables)):
dum = openFile.variables[variables[ii].name]
variables[ii].data = np.append(variables[ii].data, dum[:].data)
tmp = variables[0].data/60/60/24
time_converted = pd.to_datetime(tmp, unit='D', origin=pd.Timestamp('1900-01-01'))
return variables, time_converted
class var(object):
def __init__(self):
"""A Class that generically holds data with a variable name
and the units as attributes"""
self.name = ''
self.data = np.array([])
self.units = ''
def __repr__(self):
return_str = "name: " + self.name + '\n'
return_str += "units: " + self.units + '\n'
return_str += "data: size: " + str(self.data.shape)
return return_str
class structtype(object):
def __init__(self):
""" A class that imitates a Matlab structure type
"""
self._data = []
def __getitem__(self, index):
"""implement index behavior in the struct"""
if index == len(self._data):
self._data.append(var())
return self._data[index]
def __len__(self):
return len(self._data)
def M2M_URLs(platform_name,node,instrument_class,method):
var_list = structtype()
#MOPAK
if platform_name == 'CE01ISSM' and node == 'BUOY' and instrument_class == 'MOPAK' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/SBD17/01-MOPAK0000/telemetered/mopak_o_dcl_accel'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE02SHSM' and node == 'BUOY' and instrument_class == 'MOPAK' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/SBD11/01-MOPAK0000/telemetered/mopak_o_dcl_accel'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE04OSSM' and node == 'BUOY' and instrument_class == 'MOPAK' and method == 'Telemetered':
uframe_dataset_name = 'CE04OSSM/SBD11/01-MOPAK0000/telemetered/mopak_o_dcl_accel'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE06ISSM' and node == 'BUOY' and instrument_class == 'MOPAK' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/SBD17/01-MOPAK0000/telemetered/mopak_o_dcl_accel'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE07SHSM' and node == 'BUOY' and instrument_class == 'MOPAK' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/SBD11/01-MOPAK0000/telemetered/mopak_o_dcl_accel'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE09OSSM' and node == 'BUOY' and instrument_class == 'MOPAK' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/SBD11/01-MOPAK0000/telemetered/mopak_o_dcl_accel'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE09OSPM' and node == 'BUOY' and instrument_class == 'MOPAK' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSPM/SBS01/01-MOPAK0000/telemetered/mopak_o_dcl_accel'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
#METBK
elif platform_name == 'CE02SHSM' and node == 'BUOY' and instrument_class == 'METBK1' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/SBD11/06-METBKA000/telemetered/metbk_a_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'sea_surface_temperature'
var_list[2].name = 'sea_surface_conductivity'
var_list[3].name = 'met_salsurf'
var_list[4].name = 'met_windavg_mag_corr_east'
var_list[5].name = 'met_windavg_mag_corr_north'
var_list[6].name = 'barometric_pressure'
var_list[7].name = 'air_temperature'
var_list[8].name = 'relative_humidity'
var_list[9].name = 'longwave_irradiance'
var_list[10].name = 'shortwave_irradiance'
var_list[11].name = 'precipitation'
var_list[12].name = 'met_heatflx_minute'
var_list[13].name = 'met_latnflx_minute'
var_list[14].name = 'met_netlirr_minute'
var_list[15].name = 'met_sensflx_minute'
var_list[16].name = 'eastward_velocity'
var_list[17].name = 'northward_velocity'
var_list[18].name = 'met_spechum'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[9].data = np.array([])
var_list[10].data = np.array([])
var_list[11].data = np.array([])
var_list[12].data = np.array([])
var_list[13].data = np.array([])
var_list[14].data = np.array([])
var_list[15].data = np.array([])
var_list[16].data = np.array([])
var_list[17].data = np.array([])
var_list[18].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'S/m'
var_list[3].units = 'unitless'
var_list[4].units = 'm/s'
var_list[5].units = 'm/s'
var_list[6].units = 'mbar'
var_list[7].units = 'degC'
var_list[8].units = '#'
var_list[9].units = 'W/m'
var_list[10].units = 'W/m'
var_list[11].units = 'mm'
var_list[12].units = 'W/m'
var_list[13].units = 'W/m'
var_list[14].units = 'W/m'
var_list[15].units = 'W/m'
var_list[16].units = 'm/s'
var_list[17].units = 'm/s'
var_list[18].units = 'g/kg'
elif platform_name == 'CE04OSSM' and node == 'BUOY' and instrument_class == 'METBK1' and method == 'Telemetered':
uframe_dataset_name = 'CE04OSSM/SBD11/06-METBKA000/telemetered/metbk_a_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'sea_surface_temperature'
var_list[2].name = 'sea_surface_conductivity'
var_list[3].name = 'met_salsurf'
var_list[4].name = 'met_windavg_mag_corr_east'
var_list[5].name = 'met_windavg_mag_corr_north'
var_list[6].name = 'barometric_pressure'
var_list[7].name = 'air_temperature'
var_list[8].name = 'relative_humidity'
var_list[9].name = 'longwave_irradiance'
var_list[10].name = 'shortwave_irradiance'
var_list[11].name = 'precipitation'
var_list[12].name = 'met_heatflx_minute'
var_list[13].name = 'met_latnflx_minute'
var_list[14].name = 'met_netlirr_minute'
var_list[15].name = 'met_sensflx_minute'
var_list[16].name = 'eastward_velocity'
var_list[17].name = 'northward_velocity'
var_list[18].name = 'met_spechum'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[9].data = np.array([])
var_list[10].data = np.array([])
var_list[11].data = np.array([])
var_list[12].data = np.array([])
var_list[13].data = np.array([])
var_list[14].data = np.array([])
var_list[15].data = np.array([])
var_list[16].data = np.array([])
var_list[17].data = np.array([])
var_list[18].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'S/m'
var_list[3].units = 'unitless'
var_list[4].units = 'm/s'
var_list[5].units = 'm/s'
var_list[6].units = 'mbar'
var_list[7].units = 'degC'
var_list[8].units = '#'
var_list[9].units = 'W/m'
var_list[10].units = 'W/m'
var_list[11].units = 'mm'
var_list[12].units = 'W/m'
var_list[13].units = 'W/m'
var_list[14].units = 'W/m'
var_list[15].units = 'W/m'
var_list[16].units = 'm/s'
var_list[17].units = 'm/s'
var_list[18].units = 'g/kg'
elif platform_name == 'CE07SHSM' and node == 'BUOY' and instrument_class == 'METBK1' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/SBD11/06-METBKA000/telemetered/metbk_a_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'sea_surface_temperature'
var_list[2].name = 'sea_surface_conductivity'
var_list[3].name = 'met_salsurf'
var_list[4].name = 'met_windavg_mag_corr_east'
var_list[5].name = 'met_windavg_mag_corr_north'
var_list[6].name = 'barometric_pressure'
var_list[7].name = 'air_temperature'
var_list[8].name = 'relative_humidity'
var_list[9].name = 'longwave_irradiance'
var_list[10].name = 'shortwave_irradiance'
var_list[11].name = 'precipitation'
var_list[12].name = 'met_heatflx_minute'
var_list[13].name = 'met_latnflx_minute'
var_list[14].name = 'met_netlirr_minute'
var_list[15].name = 'met_sensflx_minute'
var_list[16].name = 'eastward_velocity'
var_list[17].name = 'northward_velocity'
var_list[18].name = 'met_spechum'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[9].data = np.array([])
var_list[10].data = np.array([])
var_list[11].data = np.array([])
var_list[12].data = np.array([])
var_list[13].data = np.array([])
var_list[14].data = np.array([])
var_list[15].data = np.array([])
var_list[16].data = np.array([])
var_list[17].data = np.array([])
var_list[18].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'S/m'
var_list[3].units = 'unitless'
var_list[4].units = 'm/s'
var_list[5].units = 'm/s'
var_list[6].units = 'mbar'
var_list[7].units = 'degC'
var_list[8].units = '#'
var_list[9].units = 'W/m'
var_list[10].units = 'W/m'
var_list[11].units = 'mm'
var_list[12].units = 'W/m'
var_list[13].units = 'W/m'
var_list[14].units = 'W/m'
var_list[15].units = 'W/m'
var_list[16].units = 'm/s'
var_list[17].units = 'm/s'
var_list[18].units = 'g/kg'
elif platform_name == 'CE09OSSM' and node == 'BUOY' and instrument_class == 'METBK1' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/SBD11/06-METBKA000/telemetered/metbk_a_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'sea_surface_temperature'
var_list[2].name = 'sea_surface_conductivity'
var_list[3].name = 'met_salsurf'
var_list[4].name = 'met_windavg_mag_corr_east'
var_list[5].name = 'met_windavg_mag_corr_north'
var_list[6].name = 'barometric_pressure'
var_list[7].name = 'air_temperature'
var_list[8].name = 'relative_humidity'
var_list[9].name = 'longwave_irradiance'
var_list[10].name = 'shortwave_irradiance'
var_list[11].name = 'precipitation'
var_list[12].name = 'met_heatflx_minute'
var_list[13].name = 'met_latnflx_minute'
var_list[14].name = 'met_netlirr_minute'
var_list[15].name = 'met_sensflx_minute'
var_list[16].name = 'eastward_velocity'
var_list[17].name = 'northward_velocity'
var_list[18].name = 'met_spechum'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[9].data = np.array([])
var_list[10].data = np.array([])
var_list[11].data = np.array([])
var_list[12].data = np.array([])
var_list[13].data = np.array([])
var_list[14].data = np.array([])
var_list[15].data = np.array([])
var_list[16].data = np.array([])
var_list[17].data = np.array([])
var_list[18].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'S/m'
var_list[3].units = 'unitless'
var_list[4].units = 'm/s'
var_list[5].units = 'm/s'
var_list[6].units = 'mbar'
var_list[7].units = 'degC'
var_list[8].units = '#'
var_list[9].units = 'W/m'
var_list[10].units = 'W/m'
var_list[11].units = 'mm'
var_list[12].units = 'W/m'
var_list[13].units = 'W/m'
var_list[14].units = 'W/m'
var_list[15].units = 'W/m'
var_list[16].units = 'm/s'
var_list[17].units = 'm/s'
var_list[18].units = 'g/kg'
#FLORT
elif platform_name == 'CE01ISSM' and node == 'NSIF' and instrument_class == 'FLORT' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/RID16/02-FLORTD000/telemetered/flort_sample'
var_list[0].name = 'time'
var_list[1].name = 'seawater_scattering_coefficient'
var_list[2].name = 'fluorometric_chlorophyll_a'
var_list[3].name = 'fluorometric_cdom'
var_list[4].name = 'total_volume_scattering_coefficient'
var_list[5].name = 'optical_backscatter'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm-1'
var_list[2].units = 'ug/L'
var_list[3].units = 'ppb'
var_list[4].units = 'm-1 sr-1'
var_list[5].units = 'm-1'
elif platform_name == 'CE01ISSM' and node == 'BUOY' and instrument_class == 'FLORT' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/SBD17/06-FLORTD000/telemetered/flort_sample'
var_list[0].name = 'time'
var_list[1].name = 'seawater_scattering_coefficient'
var_list[2].name = 'fluorometric_chlorophyll_a'
var_list[3].name = 'fluorometric_cdom'
var_list[4].name = 'total_volume_scattering_coefficient'
var_list[5].name = 'optical_backscatter'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm-1'
var_list[2].units = 'ug/L'
var_list[3].units = 'ppb'
var_list[4].units = 'm-1 sr-1'
var_list[5].units = 'm-1'
elif platform_name == 'CE06ISSM' and node == 'NSIF' and instrument_class == 'FLORT' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/RID16/02-FLORTD000/telemetered/flort_sample'
var_list[0].name = 'time'
var_list[1].name = 'seawater_scattering_coefficient'
var_list[2].name = 'fluorometric_chlorophyll_a'
var_list[3].name = 'fluorometric_cdom'
var_list[4].name = 'total_volume_scattering_coefficient'
var_list[5].name = 'optical_backscatter'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm-1'
var_list[2].units = 'ug/L'
var_list[3].units = 'ppb'
var_list[4].units = 'm-1 sr-1'
var_list[5].units = 'm-1'
elif platform_name == 'CE06ISSM' and node == 'BUOY' and instrument_class == 'FLORT' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/SBD17/06-FLORTD000/telemetered/flort_sample'
var_list[0].name = 'time'
var_list[1].name = 'seawater_scattering_coefficient'
var_list[2].name = 'fluorometric_chlorophyll_a'
var_list[3].name = 'fluorometric_cdom'
var_list[4].name = 'total_volume_scattering_coefficient'
var_list[5].name = 'optical_backscatter'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm-1'
var_list[2].units = 'ug/L'
var_list[3].units = 'ppb'
var_list[4].units = 'm-1 sr-1'
var_list[5].units = 'm-1'
elif platform_name == 'CE02SHSM' and node == 'NSIF' and instrument_class == 'FLORT' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/RID27/02-FLORTD000/telemetered/flort_sample'
var_list[0].name = 'time'
var_list[1].name = 'seawater_scattering_coefficient'
var_list[2].name = 'fluorometric_chlorophyll_a'
var_list[3].name = 'fluorometric_cdom'
var_list[4].name = 'total_volume_scattering_coefficient'
var_list[5].name = 'optical_backscatter'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm-1'
var_list[2].units = 'ug/L'
var_list[3].units = 'ppb'
var_list[4].units = 'm-1 sr-1'
var_list[5].units = 'm-1'
elif platform_name == 'CE07SHSM' and node == 'NSIF' and instrument_class == 'FLORT' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/RID27/02-FLORTD000/telemetered/flort_sample'
var_list[0].name = 'time'
var_list[1].name = 'seawater_scattering_coefficient'
var_list[2].name = 'fluorometric_chlorophyll_a'
var_list[3].name = 'fluorometric_cdom'
var_list[4].name = 'total_volume_scattering_coefficient'
var_list[5].name = 'optical_backscatter'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm-1'
var_list[2].units = 'ug/L'
var_list[3].units = 'ppb'
var_list[4].units = 'm-1 sr-1'
var_list[5].units = 'm-1'
elif platform_name == 'CE04OSSM' and node == 'NSIF' and instrument_class == 'FLORT' and method == 'Telemetered':
uframe_dataset_name = 'CE04OSSM/RID27/02-FLORTD000/telemetered/flort_sample'
var_list[0].name = 'time'
var_list[1].name = 'seawater_scattering_coefficient'
var_list[2].name = 'fluorometric_chlorophyll_a'
var_list[3].name = 'fluorometric_cdom'
var_list[4].name = 'total_volume_scattering_coefficient'
var_list[5].name = 'optical_backscatter'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm-1'
var_list[2].units = 'ug/L'
var_list[3].units = 'ppb'
var_list[4].units = 'm-1 sr-1'
var_list[5].units = 'm-1'
elif platform_name == 'CE09OSSM' and node == 'NSIF' and instrument_class == 'FLORT' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/RID27/02-FLORTD000/telemetered/flort_sample'
var_list[0].name = 'time'
var_list[1].name = 'seawater_scattering_coefficient'
var_list[2].name = 'fluorometric_chlorophyll_a'
var_list[3].name = 'fluorometric_cdom'
var_list[4].name = 'total_volume_scattering_coefficient'
var_list[5].name = 'optical_backscatter'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm-1'
var_list[2].units = 'ug/L'
var_list[3].units = 'ppb'
var_list[4].units = 'm-1 sr-1'
var_list[5].units = 'm-1'
elif platform_name == 'CE09OSPM' and node == 'PROFILER' and instrument_class == 'FLORT' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSPM/WFP01/04-FLORTK000/telemetered/flort_sample'
var_list[0].name = 'time'
var_list[1].name = 'seawater_scattering_coefficient'
var_list[2].name = 'fluorometric_chlorophyll_a'
var_list[3].name = 'fluorometric_cdom'
var_list[4].name = 'total_volume_scattering_coefficient'
var_list[5].name = 'optical_backscatter'
var_list[6].name = 'int_ctd_pressure'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm-1'
var_list[2].units = 'ug/L'
var_list[3].units = 'ppb'
var_list[4].units = 'm-1 sr-1'
var_list[5].units = 'm-1'
var_list[6].units = 'dbar'
#FDCHP
elif platform_name == 'CE02SHSM' and node == 'BUOY' and instrument_class == 'FDCHP' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/SBD12/08-FDCHPA000/telemetered/fdchp_a_dcl_instrument'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
#DOSTA
elif platform_name == 'CE01ISSM' and node == 'NSIF' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/RID16/03-DOSTAD000/telemetered/dosta_abcdjm_ctdbp_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dissolved_oxygen'
var_list[2].name = 'dosta_ln_optode_oxygen'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'umol/L'
elif platform_name == 'CE02SHSM' and node == 'NSIF' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/RID27/04-DOSTAD000/telemetered/dosta_abcdjm_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dissolved_oxygen'
var_list[2].name = 'estimated_oxygen_concentration'
var_list[3].name = 'optode_temperature'
var_list[4].name = 'dosta_abcdjm_cspp_tc_oxygen'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'umol/L'
var_list[3].units = 'degC'
var_list[4].units = 'umol/L'
elif platform_name == 'CE04OSSM' and node == 'NSIF' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE04OSSM/RID27/04-DOSTAD000/telemetered/dosta_abcdjm_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dissolved_oxygen'
var_list[2].name = 'estimated_oxygen_concentration'
var_list[3].name = 'optode_temperature'
var_list[4].name = 'dosta_abcdjm_cspp_tc_oxygen'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'umol/L'
var_list[3].units = 'degC'
var_list[4].units = 'umol/L'
elif platform_name == 'CE06ISSM' and node == 'NSIF' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/RID16/03-DOSTAD000/telemetered/dosta_abcdjm_ctdbp_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dissolved_oxygen'
var_list[2].name = 'dosta_ln_optode_oxygen'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'umol/L'
elif platform_name == 'CE07SHSM' and node == 'NSIF' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/RID27/04-DOSTAD000/telemetered/dosta_abcdjm_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dissolved_oxygen'
var_list[2].name = 'estimated_oxygen_concentration'
var_list[3].name = 'optode_temperature'
var_list[4].name = 'dosta_abcdjm_cspp_tc_oxygen'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'umol/L'
var_list[3].units = 'degC'
var_list[4].units = 'umol/L'
elif platform_name == 'CE09OSSM' and node == 'NSIF' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/RID27/04-DOSTAD000/telemetered/dosta_abcdjm_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dissolved_oxygen'
var_list[2].name = 'estimated_oxygen_concentration'
var_list[3].name = 'optode_temperature'
var_list[4].name = 'dosta_abcdjm_cspp_tc_oxygen'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'umol/L'
var_list[3].units = 'degC'
var_list[4].units = 'umol/L'
elif platform_name == 'CE01ISSM' and node == 'MFN' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/MFD37/03-DOSTAD000/telemetered/dosta_abcdjm_ctdbp_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dissolved_oxygen'
var_list[2].name = 'dosta_ln_optode_oxygen'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'umol/L'
elif platform_name == 'CE06ISSM' and node == 'MFN' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/MFD37/03-DOSTAD000/telemetered/dosta_abcdjm_ctdbp_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dissolved_oxygen'
var_list[2].name = 'dosta_ln_optode_oxygen'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'umol/L'
elif platform_name == 'CE07SHSM' and node == 'MFN' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/MFD37/03-DOSTAD000/telemetered/dosta_abcdjm_ctdbp_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dissolved_oxygen'
var_list[2].name = 'dosta_ln_optode_oxygen'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'umol/L'
elif platform_name == 'CE09OSSM' and node == 'MFN' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/MFD37/03-DOSTAD000/telemetered/dosta_abcdjm_ctdbp_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dissolved_oxygen'
var_list[2].name = 'dosta_ln_optode_oxygen'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'umol/L'
elif platform_name == 'CE09OSPM' and node == 'PROFILER' and instrument_class == 'DOSTA' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSPM/WFP01/02-DOFSTK000/telemetered/dofst_k_wfp_instrument'
var_list[0].name = 'time'
var_list[1].name = 'dofst_k_oxygen_l2'
var_list[2].name = 'dofst_k_oxygen'
var_list[3].name = 'int_ctd_pressure'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'umol/kg'
var_list[2].units = 'Hz'
var_list[3].units = 'dbar'
#ADCP
elif platform_name == 'CE02SHSM' and node == 'NSIF' and instrument_class == 'ADCP' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/RID26/01-ADCPTA000/telemetered/adcp_velocity_earth'
var_list[0].name = 'time'
var_list[1].name = 'bin_depths'
var_list[2].name = 'heading'
var_list[3].name = 'pitch'
var_list[4].name = 'roll'
var_list[5].name = 'eastward_seawater_velocity'
var_list[6].name = 'northward_seawater_velocity'
var_list[7].name = 'upward_seawater_velocity'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'meters'
var_list[2].units = 'deci-degrees'
var_list[3].units = 'deci-degrees'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'm/s'
var_list[6].units = 'm/s'
var_list[7].units = 'm/s'
elif platform_name == 'CE04OSSM' and node == 'NSIF' and instrument_class == 'ADCP' and method == 'Telemetered':
uframe_dataset_name = 'CE04OSSM/RID26/01-ADCPTC000/telemetered/adcp_velocity_earth'
var_list[0].name = 'time'
var_list[1].name = 'bin_depths'
var_list[2].name = 'heading'
var_list[3].name = 'pitch'
var_list[4].name = 'roll'
var_list[5].name = 'eastward_seawater_velocity'
var_list[6].name = 'northward_seawater_velocity'
var_list[7].name = 'upward_seawater_velocity'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'meters'
var_list[2].units = 'deci-degrees'
var_list[3].units = 'deci-degrees'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'm/s'
var_list[6].units = 'm/s'
var_list[7].units = 'm/s'
elif platform_name == 'CE07SHSM' and node == 'NSIF' and instrument_class == 'ADCP' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/RID26/01-ADCPTA000/telemetered/adcp_velocity_earth'
var_list[0].name = 'time'
var_list[1].name = 'bin_depths'
var_list[2].name = 'heading'
var_list[3].name = 'pitch'
var_list[4].name = 'roll'
var_list[5].name = 'eastward_seawater_velocity'
var_list[6].name = 'northward_seawater_velocity'
var_list[7].name = 'upward_seawater_velocity'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'meters'
var_list[2].units = 'deci-degrees'
var_list[3].units = 'deci-degrees'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'm/s'
var_list[6].units = 'm/s'
var_list[7].units = 'm/s'
elif platform_name == 'CE09OSSM' and node == 'NSIF' and instrument_class == 'ADCP' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/RID26/01-ADCPTC000/telemetered/adcp_velocity_earth'
var_list[0].name = 'time'
var_list[1].name = 'bin_depths'
var_list[2].name = 'heading'
var_list[3].name = 'pitch'
var_list[4].name = 'roll'
var_list[5].name = 'eastward_seawater_velocity'
var_list[6].name = 'northward_seawater_velocity'
var_list[7].name = 'upward_seawater_velocity'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'meters'
var_list[2].units = 'deci-degrees'
var_list[3].units = 'deci-degrees'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'm/s'
var_list[6].units = 'm/s'
var_list[7].units = 'm/s'
elif platform_name == 'CE01ISSM' and node == 'MFN' and instrument_class == 'ADCP' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/MFD35/04-ADCPTM000/telemetered/adcp_velocity_earth'
var_list[0].name = 'time'
var_list[1].name = 'bin_depths'
var_list[2].name = 'heading'
var_list[3].name = 'pitch'
var_list[4].name = 'roll'
var_list[5].name = 'eastward_seawater_velocity'
var_list[6].name = 'northward_seawater_velocity'
var_list[7].name = 'upward_seawater_velocity'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'meters'
var_list[2].units = 'deci-degrees'
var_list[3].units = 'deci-degrees'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'm/s'
var_list[6].units = 'm/s'
var_list[7].units = 'm/s'
elif platform_name == 'CE06ISSM' and node == 'MFN' and instrument_class == 'ADCP' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/MFD35/04-ADCPTM000/telemetered/adcp_velocity_earth'
var_list[0].name = 'time'
var_list[1].name = 'bin_depths'
var_list[2].name = 'heading'
var_list[3].name = 'pitch'
var_list[4].name = 'roll'
var_list[5].name = 'eastward_seawater_velocity'
var_list[6].name = 'northward_seawater_velocity'
var_list[7].name = 'upward_seawater_velocity'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'meters'
var_list[2].units = 'deci-degrees'
var_list[3].units = 'deci-degrees'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'm/s'
var_list[6].units = 'm/s'
var_list[7].units = 'm/s'
elif platform_name == 'CE07SHSM' and node == 'MFN' and instrument_class == 'ADCP' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/MFD35/04-ADCPTC000/telemetered/adcp_velocity_earth'
var_list[0].name = 'time'
var_list[1].name = 'bin_depths'
var_list[2].name = 'heading'
var_list[3].name = 'pitch'
var_list[4].name = 'roll'
var_list[5].name = 'eastward_seawater_velocity'
var_list[6].name = 'northward_seawater_velocity'
var_list[7].name = 'upward_seawater_velocity'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'meters'
var_list[2].units = 'deci-degrees'
var_list[3].units = 'deci-degrees'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'm/s'
var_list[6].units = 'm/s'
var_list[7].units = 'm/s'
elif platform_name == 'CE09OSSM' and node == 'MFN' and instrument_class == 'ADCP' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/MFD35/04-ADCPSJ000/telemetered/adcp_velocity_earth'
var_list[0].name = 'time'
var_list[1].name = 'bin_depths'
var_list[2].name = 'heading'
var_list[3].name = 'pitch'
var_list[4].name = 'roll'
var_list[5].name = 'eastward_seawater_velocity'
var_list[6].name = 'northward_seawater_velocity'
var_list[7].name = 'upward_seawater_velocity'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'meters'
var_list[2].units = 'deci-degrees'
var_list[3].units = 'deci-degrees'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'm/s'
var_list[6].units = 'm/s'
var_list[7].units = 'm/s'
#ZPLSC
elif platform_name == 'CE01ISSM' and node == 'MFN' and instrument_class == 'ZPLSC' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/MFD37/07-ZPLSCC000/telemetered/zplsc_c_instrument'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE06ISSM' and node == 'MFN' and instrument_class == 'ZPLSC' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/MFD37/07-ZPLSCC000/telemetered/zplsc_c_instrument'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE07SHSM' and node == 'MFN' and instrument_class == 'ZPLSC' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/MFD37/07-ZPLSCC000/telemetered/zplsc_c_instrument'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE09OSSM' and node == 'MFN' and instrument_class == 'ZPLSC' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/MFD37/07-ZPLSCC000/telemetered/zplsc_c_instrument'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE01ISSM' and node == 'MFN' and instrument_class == 'ZPLSC' and method == 'RecoveredHost':
uframe_dataset_name = 'CE01ISSM/MFD37/07-ZPLSCC000/recovered_host/zplsc_c_instrument'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE06ISSM' and node == 'MFN' and instrument_class == 'ZPLSC' and method == 'RecoveredHost':
uframe_dataset_name = 'CE06ISSM/MFD37/07-ZPLSCC000/recovered_host/zplsc_c_instrument'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE07SHSM' and node == 'MFN' and instrument_class == 'ZPLSC' and method == 'RecoveredHost':
uframe_dataset_name = 'CE07SHSM/MFD37/07-ZPLSCC000/recovered_host/zplsc_c_instrument'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
elif platform_name == 'CE09OSSM' and node == 'MFN' and instrument_class == 'ZPLSC' and method == 'RecoveredHost':
uframe_dataset_name = 'CE09OSSM/MFD37/07-ZPLSCC000/recovered_host/zplsc_c_instrument'
var_list[0].name = 'time'
var_list[0].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
#WAVSS
elif platform_name == 'CE02SHSM' and node == 'BUOY' and instrument_class == 'WAVSS_Stats' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/SBD12/05-WAVSSA000/telemetered/wavss_a_dcl_statistics'
var_list[0].name = 'time'
var_list[1].name = 'number_zero_crossings'
var_list[2].name = 'average_wave_height'
var_list[3].name = 'mean_spectral_period'
var_list[4].name = 'max_wave_height'
var_list[5].name = 'significant_wave_height'
var_list[6].name = 'significant_period'
var_list[7].name = 'wave_height_10'
var_list[8].name = 'wave_period_10'
var_list[9].name = 'mean_wave_period'
var_list[10].name = 'peak_wave_period'
var_list[11].name = 'wave_period_tp5'
var_list[12].name = 'wave_height_hmo'
var_list[13].name = 'mean_direction'
var_list[14].name = 'mean_spread'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[9].data = np.array([])
var_list[10].data = np.array([])
var_list[11].data = np.array([])
var_list[12].data = np.array([])
var_list[13].data = np.array([])
var_list[14].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'counts'
var_list[2].units = 'm'
var_list[3].units = 'sec'
var_list[4].units = 'm'
var_list[5].units = 'm'
var_list[6].units = 'sec'
var_list[7].units = 'm'
var_list[8].units = 'sec'
var_list[9].units = 'sec'
var_list[10].units = 'sec'
var_list[11].units = 'sec'
var_list[12].units = 'm'
var_list[13].units = 'degrees'
var_list[14].units = 'degrees'
elif platform_name == 'CE04OSSM' and node == 'BUOY' and instrument_class == 'WAVSS_Stats' and method == 'Telemetered':
uframe_dataset_name = 'CE04OSSM/SBD12/05-WAVSSA000/telemetered/wavss_a_dcl_statistics'
var_list[0].name = 'time'
var_list[1].name = 'number_zero_crossings'
var_list[2].name = 'average_wave_height'
var_list[3].name = 'mean_spectral_period'
var_list[4].name = 'max_wave_height'
var_list[5].name = 'significant_wave_height'
var_list[6].name = 'significant_period'
var_list[7].name = 'wave_height_10'
var_list[8].name = 'wave_period_10'
var_list[9].name = 'mean_wave_period'
var_list[10].name = 'peak_wave_period'
var_list[11].name = 'wave_period_tp5'
var_list[12].name = 'wave_height_hmo'
var_list[13].name = 'mean_direction'
var_list[14].name = 'mean_spread'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[9].data = np.array([])
var_list[10].data = np.array([])
var_list[11].data = np.array([])
var_list[12].data = np.array([])
var_list[13].data = np.array([])
var_list[14].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'counts'
var_list[2].units = 'm'
var_list[3].units = 'sec'
var_list[4].units = 'm'
var_list[5].units = 'm'
var_list[6].units = 'sec'
var_list[7].units = 'm'
var_list[8].units = 'sec'
var_list[9].units = 'sec'
var_list[10].units = 'sec'
var_list[11].units = 'sec'
var_list[12].units = 'm'
var_list[13].units = 'degrees'
var_list[14].units = 'degrees'
elif platform_name == 'CE07SHSM' and node == 'BUOY' and instrument_class == 'WAVSS_Stats' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/SBD12/05-WAVSSA000/telemetered/wavss_a_dcl_statistics'
var_list[0].name = 'time'
var_list[1].name = 'number_zero_crossings'
var_list[2].name = 'average_wave_height'
var_list[3].name = 'mean_spectral_period'
var_list[4].name = 'max_wave_height'
var_list[5].name = 'significant_wave_height'
var_list[6].name = 'significant_period'
var_list[7].name = 'wave_height_10'
var_list[8].name = 'wave_period_10'
var_list[9].name = 'mean_wave_period'
var_list[10].name = 'peak_wave_period'
var_list[11].name = 'wave_period_tp5'
var_list[12].name = 'wave_height_hmo'
var_list[13].name = 'mean_direction'
var_list[14].name = 'mean_spread'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[9].data = np.array([])
var_list[10].data = np.array([])
var_list[11].data = np.array([])
var_list[12].data = np.array([])
var_list[13].data = np.array([])
var_list[14].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'counts'
var_list[2].units = 'm'
var_list[3].units = 'sec'
var_list[4].units = 'm'
var_list[5].units = 'm'
var_list[6].units = 'sec'
var_list[7].units = 'm'
var_list[8].units = 'sec'
var_list[9].units = 'sec'
var_list[10].units = 'sec'
var_list[11].units = 'sec'
var_list[12].units = 'm'
var_list[13].units = 'degrees'
var_list[14].units = 'degrees'
elif platform_name == 'CE09OSSM' and node == 'BUOY' and instrument_class == 'WAVSS_Stats' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/SBD12/05-WAVSSA000/telemetered/wavss_a_dcl_statistics'
var_list[0].name = 'time'
var_list[1].name = 'number_zero_crossings'
var_list[2].name = 'average_wave_height'
var_list[3].name = 'mean_spectral_period'
var_list[4].name = 'max_wave_height'
var_list[5].name = 'significant_wave_height'
var_list[6].name = 'significant_period'
var_list[7].name = 'wave_height_10'
var_list[8].name = 'wave_period_10'
var_list[9].name = 'mean_wave_period'
var_list[10].name = 'peak_wave_period'
var_list[11].name = 'wave_period_tp5'
var_list[12].name = 'wave_height_hmo'
var_list[13].name = 'mean_direction'
var_list[14].name = 'mean_spread'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[9].data = np.array([])
var_list[10].data = np.array([])
var_list[11].data = np.array([])
var_list[12].data = np.array([])
var_list[13].data = np.array([])
var_list[14].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'counts'
var_list[2].units = 'm'
var_list[3].units = 'sec'
var_list[4].units = 'm'
var_list[5].units = 'm'
var_list[6].units = 'sec'
var_list[7].units = 'm'
var_list[8].units = 'sec'
var_list[9].units = 'sec'
var_list[10].units = 'sec'
var_list[11].units = 'sec'
var_list[12].units = 'm'
var_list[13].units = 'degrees'
var_list[14].units = 'degrees'
#VELPT
elif platform_name == 'CE01ISSM' and node == 'BUOY' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/SBD17/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE02SHSM' and node == 'BUOY' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/SBD11/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE04OSSM' and node == 'BUOY' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE04OSSM/SBD11/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE06ISSM' and node == 'BUOY' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/SBD17/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE07SHSM' and node == 'BUOY' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/SBD11/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE09OSSM' and node == 'BUOY' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/SBD11/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE01ISSM' and node == 'NSIF' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/RID16/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE02SHSM' and node == 'NSIF' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/RID26/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE04OSSM' and node == 'NSIF' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE04OSSM/RID26/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE06ISSM' and node == 'NSIF' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/RID16/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE07SHSM' and node == 'NSIF' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/RID26/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
elif platform_name == 'CE09OSSM' and node == 'NSIF' and instrument_class == 'VELPT' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/RID26/04-VELPTA000/telemetered/velpt_ab_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'eastward_velocity'
var_list[2].name = 'northward_velocity'
var_list[3].name = 'upward_velocity'
var_list[4].name = 'heading_decidegree'
var_list[5].name = 'roll_decidegree'
var_list[6].name = 'pitch_decidegree'
var_list[7].name = 'temperature_centidegree'
var_list[8].name = 'pressure_mbar'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[3].data = np.array([])
var_list[4].data = np.array([])
var_list[5].data = np.array([])
var_list[6].data = np.array([])
var_list[7].data = np.array([])
var_list[8].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'm/s'
var_list[2].units = 'm/s'
var_list[3].units = 'm/s'
var_list[4].units = 'deci-degrees'
var_list[5].units = 'deci-degrees'
var_list[6].units = 'deci-degrees'
var_list[7].units = '0.01degC'
var_list[8].units = '0.001dbar'
#PCO2W
elif platform_name == 'CE01ISSM' and node == 'NSIF' and instrument_class == 'PCO2W' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/RID16/05-PCO2WB000/telemetered/pco2w_abc_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'pco2w_thermistor_temperature'
var_list[2].name = 'pco2_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'uatm'
elif platform_name == 'CE01ISSM' and node == 'MFN' and instrument_class == 'PCO2W' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/MFD35/05-PCO2WB000/telemetered/pco2w_abc_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'pco2w_thermistor_temperature'
var_list[2].name = 'pco2_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'uatm'
elif platform_name == 'CE06ISSM' and node == 'NSIF' and instrument_class == 'PCO2W' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/RID16/05-PCO2WB000/telemetered/pco2w_abc_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'pco2w_thermistor_temperature'
var_list[2].name = 'pco2_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'uatm'
elif platform_name == 'CE06ISSM' and node == 'MFN' and instrument_class == 'PCO2W' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/MFD35/05-PCO2WB000/telemetered/pco2w_abc_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'pco2w_thermistor_temperature'
var_list[2].name = 'pco2_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'uatm'
elif platform_name == 'CE07SHSM' and node == 'MFN' and instrument_class == 'PCO2W' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/MFD35/05-PCO2WB000/telemetered/pco2w_abc_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'pco2w_thermistor_temperature'
var_list[2].name = 'pco2_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'uatm'
elif platform_name == 'CE09OSSM' and node == 'MFN' and instrument_class == 'PCO2W' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/MFD35/05-PCO2WB000/telemetered/pco2w_abc_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'pco2w_thermistor_temperature'
var_list[2].name = 'pco2_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'uatm'
#PHSEN
elif platform_name == 'CE01ISSM' and node == 'NSIF' and instrument_class == 'PHSEN' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/RID16/06-PHSEND000/telemetered/phsen_abcdef_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'phsen_thermistor_temperature'
var_list[2].name = 'phsen_abcdef_ph_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'unitless'
elif platform_name == 'CE02SHSM' and node == 'NSIF' and instrument_class == 'PHSEN' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/RID26/06-PHSEND000/telemetered/phsen_abcdef_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'phsen_thermistor_temperature'
var_list[2].name = 'phsen_abcdef_ph_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'unitless'
elif platform_name == 'CE04OSSM' and node == 'NSIF' and instrument_class == 'PHSEN' and method == 'Telemetered':
uframe_dataset_name = 'CE04OSSM/RID26/06-PHSEND000/telemetered/phsen_abcdef_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'phsen_thermistor_temperature'
var_list[2].name = 'phsen_abcdef_ph_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'unitless'
elif platform_name == 'CE06ISSM' and node == 'NSIF' and instrument_class == 'PHSEN' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/RID16/06-PHSEND000/telemetered/phsen_abcdef_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'phsen_thermistor_temperature'
var_list[2].name = 'phsen_abcdef_ph_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'unitless'
elif platform_name == 'CE07SHSM' and node == 'NSIF' and instrument_class == 'PHSEN' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/RID26/06-PHSEND000/telemetered/phsen_abcdef_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'phsen_thermistor_temperature'
var_list[2].name = 'phsen_abcdef_ph_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'unitless'
elif platform_name == 'CE09OSSM' and node == 'NSIF' and instrument_class == 'PHSEN' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/RID26/06-PHSEND000/telemetered/phsen_abcdef_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'phsen_thermistor_temperature'
var_list[2].name = 'phsen_abcdef_ph_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'unitless'
elif platform_name == 'CE01ISSM' and node == 'MFN' and instrument_class == 'PHSEN' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/MFD35/06-PHSEND000/telemetered/phsen_abcdef_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'phsen_thermistor_temperature'
var_list[2].name = 'phsen_abcdef_ph_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'unitless'
elif platform_name == 'CE06ISSM' and node == 'MFN' and instrument_class == 'PHSEN' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/MFD35/06-PHSEND000/telemetered/phsen_abcdef_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'phsen_thermistor_temperature'
var_list[2].name = 'phsen_abcdef_ph_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'unitless'
elif platform_name == 'CE07SHSM' and node == 'MFN' and instrument_class == 'PHSEN' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/MFD35/06-PHSEND000/telemetered/phsen_abcdef_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'phsen_thermistor_temperature'
var_list[2].name = 'phsen_abcdef_ph_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'unitless'
elif platform_name == 'CE09OSSM' and node == 'MFN' and instrument_class == 'PHSEN' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/MFD35/06-PHSEND000/telemetered/phsen_abcdef_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'phsen_thermistor_temperature'
var_list[2].name = 'phsen_abcdef_ph_seawater'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'degC'
var_list[2].units = 'unitless'
#SPKIR
elif platform_name == 'CE01ISSM' and node == 'NSIF' and instrument_class == 'SPKIR' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/RID16/08-SPKIRB000/telemetered/spkir_abj_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'spkir_abj_cspp_downwelling_vector'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'uW cm-2 nm-1'
elif platform_name == 'CE02SHSM' and node == 'NSIF' and instrument_class == 'SPKIR' and method == 'Telemetered':
uframe_dataset_name = 'CE02SHSM/RID26/08-SPKIRB000/telemetered/spkir_abj_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'spkir_abj_cspp_downwelling_vector'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'uW cm-2 nm-1'
elif platform_name == 'CE04OSSM' and node == 'NSIF' and instrument_class == 'SPKIR' and method == 'Telemetered':
uframe_dataset_name = 'CE04OSSM/RID26/08-SPKIRB000/telemetered/spkir_abj_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'spkir_abj_cspp_downwelling_vector'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'uW cm-2 nm-1'
elif platform_name == 'CE06ISSM' and node == 'NSIF' and instrument_class == 'SPKIR' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/RID16/08-SPKIRB000/telemetered/spkir_abj_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'spkir_abj_cspp_downwelling_vector'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'uW cm-2 nm-1'
elif platform_name == 'CE07SHSM' and node == 'NSIF' and instrument_class == 'SPKIR' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/RID26/08-SPKIRB000/telemetered/spkir_abj_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'spkir_abj_cspp_downwelling_vector'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'uW cm-2 nm-1'
elif platform_name == 'CE09OSSM' and node == 'NSIF' and instrument_class == 'SPKIR' and method == 'Telemetered':
uframe_dataset_name = 'CE09OSSM/RID26/08-SPKIRB000/telemetered/spkir_abj_dcl_instrument'
var_list[0].name = 'time'
var_list[1].name = 'spkir_abj_cspp_downwelling_vector'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'uW cm-2 nm-1'
#PRESF
elif platform_name == 'CE01ISSM' and node == 'MFN' and instrument_class == 'PRESF' and method == 'Telemetered':
uframe_dataset_name = 'CE01ISSM/MFD35/02-PRESFA000/telemetered/presf_abc_dcl_tide_measurement'
var_list[0].name = 'time'
var_list[1].name = 'abs_seafloor_pressure'
var_list[2].name = 'seawater_temperature'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'dbar'
var_list[2].units = 'degC'
elif platform_name == 'CE06ISSM' and node == 'MFN' and instrument_class == 'PRESF' and method == 'Telemetered':
uframe_dataset_name = 'CE06ISSM/MFD35/02-PRESFA000/telemetered/presf_abc_dcl_tide_measurement'
var_list[0].name = 'time'
var_list[1].name = 'abs_seafloor_pressure'
var_list[2].name = 'seawater_temperature'
var_list[0].data = np.array([])
var_list[1].data = np.array([])
var_list[2].data = np.array([])
var_list[0].units = 'seconds since 1900-01-01'
var_list[1].units = 'dbar'
var_list[2].units = 'degC'
elif platform_name == 'CE07SHSM' and node == 'MFN' and instrument_class == 'PRESF' and method == 'Telemetered':
uframe_dataset_name = 'CE07SHSM/MFD35/02-PRESFB000/telemetered/presf_abc_dcl_tide_measurement'
var_list[0].name = 'time'
var_list[1].name = 'abs_seafloor_pressure'
var_list[2].name = 'seawater_temperature'
var_list[0].data = | np.array([]) | numpy.array |
import pytest
import numpy as np
import pandas as pd
import numpy.testing as npt
import pandas.testing as pdt
from scipy.stats import logistic
import zepid as ze
from zepid import (RiskRatio, RiskDifference, OddsRatio, NNT, IncidenceRateRatio, IncidenceRateDifference,
Sensitivity, Specificity, Diagnostics, interaction_contrast, interaction_contrast_ratio, spline,
table1_generator)
from zepid.calc import sensitivity, specificity
@pytest.fixture
def data_set():
df = pd.DataFrame()
df['exp'] = [1]*50 + [0]*50
df['dis'] = [1]*25 + [0]*25 + [1]*25 + [0]*25
return df
@pytest.fixture
def multi_exposures():
df = pd.DataFrame()
df['exp'] = [1]*50 + [0]*50 + [2]*50
df['dis'] = [1]*25 + [0]*25 + [1]*25 + [0]*25 + [1]*25 + [0]*25
return df
@pytest.fixture
def time_data():
df = pd.DataFrame()
df['exp'] = [1]*50 + [0]*50
df['dis'] = [1]*6 + [0]*44 + [1]*14 + [0]*36
df['t'] = [2]*50 + [8]*50
return df
class TestRiskRatio:
def test_risk_ratio_reference_equal_to_1(self, data_set):
rr = RiskRatio()
rr.fit(data_set, exposure='exp', outcome='dis')
assert rr.risk_ratio[0] == 1
def test_risk_ratio_equal_to_1(self, data_set):
rr = RiskRatio()
rr.fit(data_set, exposure='exp', outcome='dis')
assert rr.risk_ratio[1] == 1
def test_multiple_exposures(self, multi_exposures):
rr = RiskRatio()
rr.fit(multi_exposures, exposure='exp', outcome='dis')
assert rr.results.shape[0] == 3
assert list(rr.results.index) == ['Ref:0', '1', '2']
def test_match_sas_ci(self, data_set):
sas_ci = 0.6757, 1.4799
rr = RiskRatio()
rr.fit(data_set, exposure='exp', outcome='dis')
df = rr.results
npt.assert_allclose(np.round(df.loc[df.index == '1'][['RR_LCL', 'RR_UCL']], 4), [sas_ci])
def test_match_sas_sampledata(self):
sas_rd = 0.742118331
sas_se = 0.312612740
sas_ci = 0.402139480, 1.369523870
df = ze.load_sample_data(False)
rr = RiskRatio()
rr.fit(df, exposure='art', outcome='dead')
npt.assert_allclose(rr.risk_ratio[1], sas_rd, rtol=1e-5)
rf = rr.results
npt.assert_allclose(rf.loc[rf.index == '1'][['RR_LCL', 'RR_UCL']], [sas_ci], rtol=1e-5)
npt.assert_allclose(rf.loc[rf.index == '1'][['SD(RR)']], sas_se, rtol=1e-5)
class TestRiskDifference:
def test_risk_difference_reference_equal_to_0(self, data_set):
rd = RiskDifference()
rd.fit(data_set, exposure='exp', outcome='dis')
assert rd.risk_difference[0] == 0
def test_risk_difference_equal_to_0(self, data_set):
rd = RiskDifference()
rd.fit(data_set, exposure='exp', outcome='dis')
assert rd.risk_difference[1] == 0
def test_multiple_exposures(self, multi_exposures):
rd = RiskDifference()
rd.fit(multi_exposures, exposure='exp', outcome='dis')
assert rd.results.shape[0] == 3
assert list(rd.results.index) == ['Ref:0', '1', '2']
def test_match_sas_ci(self, data_set):
sas_ci = -0.195996398, 0.195996398
rd = RiskDifference()
rd.fit(data_set, exposure='exp', outcome='dis')
df = rd.results
npt.assert_allclose(df.loc[df.index == '1'][['RD_LCL', 'RD_UCL']], [sas_ci])
def test_match_sas_se(self, data_set):
sas_se = 0.1
rd = RiskDifference()
rd.fit(data_set, exposure='exp', outcome='dis')
df = rd.results
npt.assert_allclose(df.loc[df.index == '1'][['SD(RD)']], sas_se)
def test_match_sas_sampledata(self):
sas_rr = -0.045129870
sas_se = 0.042375793
sas_ci = -0.128184899, 0.037925158
df = ze.load_sample_data(False)
rd = RiskDifference()
rd.fit(df, exposure='art', outcome='dead')
npt.assert_allclose(rd.risk_difference[1], sas_rr)
rf = rd.results
npt.assert_allclose(rf.loc[rf.index == '1'][['RD_LCL', 'RD_UCL']], [sas_ci])
npt.assert_allclose(rf.loc[rf.index == '1'][['SD(RD)']], sas_se)
def test_frechet_bounds(self):
df = ze.load_sample_data(False)
rd = RiskDifference()
rd.fit(df, exposure='art', outcome='dead')
npt.assert_allclose(rd.results['UpperBound'][1] - rd.results['LowerBound'][1], 1.0000)
def test_frechet_bounds2(self, multi_exposures):
rd = RiskDifference()
rd.fit(multi_exposures, exposure='exp', outcome='dis')
npt.assert_allclose(rd.results['UpperBound'][1:] - rd.results['LowerBound'][1:], [1.0000, 1.0000])
class TestOddsRatio:
def test_odds_ratio_reference_equal_to_1(self, data_set):
ord = OddsRatio()
ord.fit(data_set, exposure='exp', outcome='dis')
assert ord.odds_ratio[0] == 1
def test_odds_ratio_equal_to_1(self, data_set):
ord = OddsRatio()
ord.fit(data_set, exposure='exp', outcome='dis')
assert ord.odds_ratio[1] == 1
def test_multiple_exposures(self, multi_exposures):
ord = OddsRatio()
ord.fit(multi_exposures, exposure='exp', outcome='dis')
assert ord.results.shape[0] == 3
assert list(ord.results.index) == ['Ref:0', '1', '2']
def test_match_sas_ci(self, data_set):
sas_ci = 0.4566, 2.1902
ord = OddsRatio()
ord.fit(data_set, exposure='exp', outcome='dis')
df = ord.results
npt.assert_allclose(df.loc[df.index == '1'][['OR_LCL', 'OR_UCL']], [sas_ci], rtol=1e-4)
def test_match_sas_sampledata(self):
sas_or = 0.7036
sas_se = 0.361479191
sas_ci = 0.3465, 1.4290
df = ze.load_sample_data(False)
ord = OddsRatio()
ord.fit(df, exposure='art', outcome='dead')
| npt.assert_allclose(ord.odds_ratio[1], sas_or, rtol=1e-4) | numpy.testing.assert_allclose |
from __future__ import division, print_function, absolute_import
import numpy
from numpy import (atleast_1d, poly, polyval, roots, real, asarray,
resize, pi, absolute, logspace, r_, sqrt, tan, log10,
arctan, arcsinh, sin, exp, cosh, arccosh, ceil, conjugate,
zeros, sinh, append, concatenate, prod, ones, array,
mintypecode)
from .filters import *
from .helpers import fminbound, fmin, newton
from mpmath import ellipk, ellipfun, besselk
import numpy as np
__all__ = ['iirfilter', 'cheb1ord', 'cheb2ord', 'buttord']
def iirfilter(N, Wn, rp=None, rs=None, btype='band', analog=False,
ftype='butter', output='ba'):
"""
IIR digital and analog filter design given order and critical points.
Design an Nth-order digital or analog filter and return the filter
coefficients.
Parameters
----------
N : int
The order of the filter.
Wn : array_like
A scalar or length-2 sequence giving the critical frequencies.
For digital filters, `Wn` is normalized from 0 to 1, where 1 is the
Nyquist frequency, pi radians/sample. (`Wn` is thus in
half-cycles / sample.)
For analog filters, `Wn` is an angular frequency (e.g. rad/s).
rp : float, optional
For Chebyshev and elliptic filters, provides the maximum ripple
in the passband. (dB)
rs : float, optional
For Chebyshev and elliptic filters, provides the minimum attenuation
in the stop band. (dB)
btype : {'bandpass', 'lowpass', 'highpass', 'bandstop'}, optional
The type of filter. Default is 'bandpass'.
analog : bool, optional
When True, return an analog filter, otherwise a digital filter is
returned.
ftype : str, optional
The type of IIR filter to design:
- Butterworth : 'butter'
- Chebyshev I : 'cheby1'
- Chebyshev II : 'cheby2'
- Cauer/elliptic: 'ellip'
- Bessel/Thomson: 'bessel'
output : {'ba', 'zpk', 'sos'}, optional
Type of output: numerator/denominator ('ba') or pole-zero ('zpk').
Default is 'ba'.
Returns
-------
b, a : ndarray, ndarray
Numerator (`b`) and denominator (`a`) polynomials of the IIR filter.
Only returned if ``output='ba'``.
z, p, k : ndarray, ndarray, float
Zeros, poles, and system gain of the IIR filter transfer
function. Only returned if ``output='zpk'``.
sos : ndarray
Second-order sections representation of the IIR filter.
Only returned if ``output=='sos'``.
See Also
--------
butter : Filter design using order and critical points
cheby1, cheby2, ellip, bessel
buttord : Find order and critical points from passband and stopband spec
cheb1ord, cheb2ord, ellipord
iirdesign : General filter design using passband and stopband spec
Notes
-----
The ``'sos'`` output parameter was added in 0.16.0.
Examples
--------
Generate a 17th-order Chebyshev II bandpass filter and plot the frequency
response:
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> b, a = signal.iirfilter(17, [50, 200], rs=60, btype='band',
... analog=True, ftype='cheby2')
>>> w, h = signal.freqs(b, a, 1000)
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> ax.semilogx(w, 20 * np.log10(abs(h)))
>>> ax.set_title('Chebyshev Type II bandpass frequency response')
>>> ax.set_xlabel('Frequency [radians / second]')
>>> ax.set_ylabel('Amplitude [dB]')
>>> ax.axis((10, 1000, -100, 10))
>>> ax.grid(which='both', axis='both')
>>> plt.show()
"""
ftype, btype, output = [x.lower() for x in (ftype, btype, output)]
Wn = asarray(Wn)
try:
btype = band_dict[btype]
except KeyError:
raise ValueError("'%s' is an invalid bandtype for filter." % btype)
try:
typefunc = filter_dict[ftype][0]
except KeyError:
raise ValueError("'%s' is not a valid basic IIR filter." % ftype)
if output not in ['ba', 'zpk']:
raise ValueError("'%s' is not a valid output form." % output)
if rp is not None and rp < 0:
raise ValueError("passband ripple (rp) must be positive")
if rs is not None and rs < 0:
raise ValueError("stopband attenuation (rs) must be positive")
# Get analog lowpass prototype
if typefunc == buttap:
z, p, k = typefunc(N)
# elif typefunc == besselap:
# z, p, k = typefunc(N, norm=bessel_norms[ftype])
elif typefunc == cheb1ap:
if rp is None:
raise ValueError("passband ripple (rp) must be provided to "
"design a Chebyshev I filter.")
z, p, k = typefunc(N, rp)
elif typefunc == cheb2ap:
if rs is None:
raise ValueError("stopband attenuation (rs) must be provided to "
"design an Chebyshev II filter.")
z, p, k = typefunc(N, rs)
# elif typefunc == ellipap:
# if rs is None or rp is None:
# raise ValueError("Both rp and rs must be provided to design an "
# "elliptic filter.")
# z, p, k = typefunc(N, rp, rs)
else:
raise NotImplementedError("'%s' not implemented in iirfilter." % ftype)
# Pre-warp frequencies for digital filter design
if not analog:
if | numpy.any(Wn <= 0) | numpy.any |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 14 19:50:56 2020
@author: hiroyasu
"""
import cvxpy as cp
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import control
import SCPmulti as scp
import pickle
import TrainRNN as trnn
import torch
import pandas as pd
DT = scp.DT
TSPAN = scp.TSPAN
M = scp.M
II = scp.II
L = scp.L
bb = scp.bb
FMIN = scp.FMIN
FMAX = scp.FMAX
RungeNum = scp.RungeNum
AA = scp.AA
Robs = scp.Robs
Rsafe = scp.Rsafe
XOBSs = scp.XOBSs
XXd0 = np.load('data/params/desired_n/Xhis.npy')
UUd0 = np.load('data/params/desired_n/Uhis.npy')
dratio = 0.2
d_over = np.sqrt(3)*dratio
X0 = scp.X0
Xf = scp.Xf
n_input = trnn.n_input
n_hidden = trnn.n_hidden
n_output = trnn.n_output
n_layers = trnn.n_layers
class Spacecraft:
def __init__(self,XXd0,UUd0,tspan=TSPAN,dt=DT,runge_num=RungeNum,m=M,I=II,l=L,b=bb,A=AA,fmin=FMIN,fmax=FMAX):
self.XXd = XXd0
self.UUd = UUd0
self.tspan = tspan
self.dt = dt
self.runge_num = runge_num
self.h = dt/runge_num
self.m = m
self.I = I
self.l = l
self.b = b
self.A = A
self.fmin = fmin
self.fmax = fmax
self.net = trnn.RNN(n_input,n_hidden,n_output,n_layers)
self.net.load_state_dict(torch.load('data/trained_nets/RNNLorenz.pt'))
self.net.eval()
self.YC = np.load('data/trained_nets/Y_params.npy')
self.ns = 6
self.RNN = 1
def GetP(self,X):
Xnet = self.Np2Var(X)
if self.RNN == 1:
cP = self.net(Xnet.view(1,1,-1))
cP = cP.data.numpy()*self.YC
P = self.cP2P(cP[0,0,:])
else:
cP = self.net(Xnet)
cP = cP.data.numpy()
P = self.cP2P(cP)
return P
def GetK(self,X):
P = self.GetP(X)
B = self.GetB(X)
K = B.T@P
return K
def Np2Var(self,X):
X = X.astype(np.float32)
X = torch.from_numpy(X)
return X
def cP2P(self,cP):
cPnp = 0
for i in range(self.ns):
lb = i*(i+1)/2
lb = int(lb)
ub = (i+1)*(i+2)/2
ub = int(ub)
Di = cP[lb:ub]
Di = np.diag(Di,self.ns-(i+1))
cPnp += Di
P = (cPnp.T)@cPnp
return P
def GetPdot(self,X,Ud,Xdp1):
dX = Xdp1-X
P = self.GetP(X)
Pdot = 0
dXdt = self.dynamics(0,X,Ud)
for i in range(self.ns):
dx = np.zeros(self.ns)
dx[i] = dX[i]
Pdot += (self.GetP(X+dx)-P)/np.linalg.norm(dx)*dXdt[i]
return Pdot
def dynamics(self,t,states,inputs):
A = self.A
B = self.GetB(states)
Xv = np.transpose(np.array([states]))
Uv = np.transpose(np.array([inputs]))
dXdt = A.dot(Xv)+B.dot(Uv)
dXdt = dXdt[:,0]
return dXdt
def GetB(self,states):
m = self.m
I = self.I
l = self.l
b = self.b
th = states[2]
T = np.array([[np.cos(th)/m,np.sin(th)/m,0],[-np.sin(th)/m,np.cos(th)/m,0],[0,0,1/2./I]])
H = np.array([[-1,-1,0,0,1,1,0,0],[0,0,-1,-1,0,0,1,1],[-l,l,-b,b,-l,l,-b,b]])
B = np.vstack((np.zeros((3,8)),T@H))
return B
def rk4(self,t,X,U):
h = self.h
k1 = self.dynamics(t,X,U)
k2 = self.dynamics(t+h/2.,X+k1*h/2.,U)
k3 = self.dynamics(t+h/2.,X+k2*h/2.,U)
k4 = self.dynamics(t+h,X+k3*h,U)
return t+h,X+h*(k1+2.*k2+2.*k3+k4)/6.
def one_step_sim(self,t,X,U):
runge_num = self.runge_num
for num in range(0, runge_num):
t,X = self.rk4(t,X,U)
return t,X
def GetCCM(self,alp):
dt = self.dt
epsilon = 0.
XX = self.XXd
N = XX.shape[0]-1
I = np.identity(6)
WW = {}
for i in range(N+1):
WW[i] = cp.Variable((6,6),PSD=True)
nu = cp.Variable(nonneg=True)
chi = cp.Variable(nonneg=True)
constraints = [chi*I-WW[0] >> epsilon*I,WW[0]-I >> epsilon*I]
for k in range(N):
Xk = XX[k,:]
Ax = self.A
Bx = self.GetB(Xk)
Wk = WW[k]
Wkp1 = WW[k+1]
constraints += [-2*alp*Wk-(-(Wkp1-Wk)/dt+Ax@[email protected]*nu*[email protected]) >> epsilon*I]
constraints += [chi*I-Wkp1 >> epsilon*I,Wkp1-I >> epsilon*I]
prob = cp.Problem(cp.Minimize(chi),constraints)
prob.solve(solver=cp.MOSEK)
cvx_status = prob.status
print(cvx_status)
WWout = {}
MMout = {}
for i in range(N+1):
WWout[i] = WW[i].value/nu.value
MMout[i] = np.linalg.inv(WWout[i])
chi = chi.value
nu = nu.value
cvx_optval = chi/alp
return cvx_status,cvx_optval,WWout,MMout,chi,nu
def CLFQP(self,X,Xd,Xdp1,M,Ud,alp):
dt = self.dt
U = cp.Variable((8,1))
Ud = np.array([Ud]).T
p = cp.Variable((1,1))
fmin = self.fmin
fmax = self.fmax
A = self.A
Bx = self.GetB(X)
Bxd = self.GetB(Xd)
evec = np.array([X-Xd]).T
Mdot = self.GetPdot(X,Ud,Xdp1)
constraints = [evec.T@(Mdot+M@A+A.T@M)@evec+2*evec.T@M@Bx@U-2*evec.T@M@Bxd@Ud <= -2*alp*evec.T@M@evec+p]
for i in range(8):
constraints += [U[i,0] <= fmax, U[i,0] >= fmin]
prob = cp.Problem(cp.Minimize(cp.sum_squares(U-Ud)+p**2),constraints)
prob.solve()
cvx_status = prob.status
U = U.value
U = np.ravel(U)
return U
def FinalTrajectory(self,MM,alp,XXdRCT,UUdRCT):
dt = self.dt
XXd = self.XXd
UUd = self.UUd
N = UUd.shape[0]
X0 = XXd[0,:]
B = self.GetB(X0)
t = 0
t1 = 0
t2 = 0
X1 = X0
X2 = X0
X3 = X0
Xd = XXd[0,:]
XdRCT = XXdRCT[0,:]
this = np.zeros(N+1)
X1his = np.zeros((N+1,X0.size))
X2his = np.zeros((N+1,X0.size))
X3his = np.zeros((N+1,X0.size))
this[0] = t
X1his[0,:] = X1
U1his = np.zeros((N,B.shape[1]))
X2his[0,:] = X2
U2his = np.zeros((N,B.shape[1]))
X3his[0,:] = X3
U3his = np.zeros((N,B.shape[1]))
U1hisN = np.zeros(N)
U2hisN = np.zeros(N)
U3hisN = np.zeros(N)
U1hisND = np.zeros(N)
U2hisND = np.zeros(N)
U3hisND = np.zeros(N)
dnMs = np.zeros(N)
dnUs = np.zeros(N)
dnXs = np.zeros(N)
for i in range(N):
M = MM[i]
A = self.A
Bx3 = self.GetB(X3)
Q = 2.4*np.identity(6)
R = 1*np.identity(8)
K,P,E = control.lqr(A,Bx3,Q,R)
P1 = self.GetP(X1)
U3 = UUd[i,:]-Bx3.T@P@(X3-Xd)
for j in range(8):
if U3[j] >= self.fmax:
U3[j] = self.fmax
elif U3[j] <= self.fmin:
U3[j] = self.fmin
#U1 = self.CLFQP(X1,Xd,XXd[i+1,:],P,UUd[i,:],alp)
U1 = self.CLFQP(X1,XdRCT,XXdRCT[i+1,:],P1,UUdRCT[i,:],alp)
U2 = self.CLFQP(X2,XdRCT,XXdRCT[i+1,:],M,UUdRCT[i,:],alp)
t,X1 = self.one_step_sim(t,X1,U1)
t1,X2 = self.one_step_sim(t1,X2,U2)
t2,X3 = self.one_step_sim(t2,X3,U3)
Xd = XXd[i+1,:]
XdRCT = XXdRCT[i+1,:]
d1 = np.random.choice(np.array([-1,1]),1)[0]
d2 = np.random.choice(np.array([-1,1]),1)[0]
d3 = np.random.choice(np.array([-1,1]),1)[0]
d1 = np.array([0,0,0,d1,d2,d3])*2
#d1 = 0
#d1 = np.hstack((np.zeros(3),(np.random.rand(3)*2-1)))*dratio*20
#d1 = (np.random.rand(6)*2-1)*0.1
X1 = X1+d1*dt
X2 = X2+d1*dt
X3 = X3+d1*dt
this[i+1] = t
X1his[i+1,:] = X1
U1his[i,:] = U1
X2his[i+1,:] = X2
U2his[i,:] = U2
X3his[i+1,:] = X3
U3his[i,:] = U3
U1hisN[i] = np.linalg.norm(U1)
U2hisN[i] = np.linalg.norm(U2)
U3hisN[i] = np.linalg.norm(U3)
U1hisND[i] = np.linalg.norm(U1-UUd[i,:])
U2hisND[i] = np.linalg.norm(U2-UUdRCT[i,:])
U3hisND[i] = np.linalg.norm(U3-UUdRCT[i,:])
dnMs[i] = np.linalg.norm(M-P1,ord=2)
dnUs[i] = np.linalg.norm(U1-U2)
dnXs[i] = np.linalg.norm(X1-X2)
return this,X1his,U1his,X2his,U2his,X3his,U3his,U1hisN,U2hisN,U3hisN,U1hisND,U2hisND,U3hisND,dnMs,dnUs,dnXs
def Rot2d(th):
R = np.array([[np.cos(th),-np.sin(th)],[np.sin(th),np.cos(th)]])
return R
def GetTubePlot(XXdRCT,alp,chi,d_over,th):
Rtube = d_over*np.sqrt(chi)/alp
xxdRCT = XXdRCT[:,0:2]
dxxdRCT = np.diff(xxdRCT,axis=0)
for i in range(dxxdRCT.shape[0]):
dxxdRCT[i,:] = Rot2d(th)@(dxxdRCT[i,:]/np.linalg.norm(dxxdRCT[i,:]))
return xxdRCT[0:dxxdRCT.shape[0],:]+dxxdRCT*Rtube
def SaveDict(filename,var):
output = open(filename,'wb')
pickle.dump(var,output)
output.close()
pass
def LoadDict(filename):
pkl_file = open(filename,'rb')
varout = pickle.load(pkl_file)
pkl_file.close()
return varout
if __name__ == "__main__":
sc = Spacecraft(XXd0,UUd0)
alp = | np.load('data/params/alpha_mmicro/alp.npy') | numpy.load |
import numpy as np
from tqdm import tqdm
import gensim
import os
import wget
import sys
import shutil
from ufal.udpipe import Model, Pipeline
from sklearn.metrics.pairwise import cosine_similarity
from nltk.translate.bleu_score import sentence_bleu
from nltk.translate.bleu_score import corpus_bleu
DATA_DIR = "../data"
fasttext_model_url = "http://vectors.nlpl.eu/repository/20/213.zip"
fasttext_filename = "ru_fasttext/model.model"
if not os.path.isfile(os.path.join(DATA_DIR, fasttext_filename)):
print("FastText model not found. Downloading...", file=sys.stderr)
wget.download(fasttext_model_url, out=DATA_DIR)
shutil.unpack_archive(os.path.join(DATA_DIR, fasttext_model_url.split("/")[-1]), os.path.join(DATA_DIR, "ru_fasttext/"))
model = gensim.models.KeyedVectors.load(os.path.join(DATA_DIR, fasttext_filename))
udpipe_model_url = "https://rusvectores.org/static/models/udpipe_syntagrus.model"
udpipe_filename = udpipe_model_url.split("/")[-1]
if not os.path.isfile(os.path.join(DATA_DIR, udpipe_filename)):
print("\nUDPipe model not found. Downloading...", file=sys.stderr)
wget.download(udpipe_model_url, out=DATA_DIR)
model_udpipe = Model.load(os.path.join(DATA_DIR, udpipe_filename))
process_pipeline = Pipeline(model_udpipe, 'tokenize', Pipeline.DEFAULT, Pipeline.DEFAULT, 'conllu')
def tokenize(text, tags=False, lemmas=False):
processed = process_pipeline.process(text)
content = [l for l in processed.split('\n') if not l.startswith('#')]
tagged = [w.split('\t') for w in content if w]
tokens = []
for token in tagged:
if token[3] == 'PUNCT':
continue
token_res = ''
if lemmas:
token_res = token[2]
else:
token_res = token[1]
if tags:
token_res += '_' + token[3]
tokens.append(token_res)
return tokens
def get_sentence_vector(text):
tokens = tokenize(text, lemmas=True)
embd = [model[token] for token in tokens]
return np.mean(embd, axis=0).reshape(1, -1)
def get_cosine_sim(text1, text2):
try:
return cosine_similarity(get_sentence_vector(text1), get_sentence_vector(text2))
except:
return 0
def get_cosine_sim_corpus(original_sentences, transferred_sentences):
results = []
for index in tqdm(range(len(original_sentences))):
results.append(get_cosine_sim(original_sentences[index], transferred_sentences[index]))
return np.mean(results)
def get_word_overlap(text1, text2):
tokens1 = tokenize(text1, lemmas=True)
tokens2 = tokenize(text2, lemmas=True)
union = set(tokens1 + tokens2)
intersection = list(set(tokens1) & set(tokens2))
return len(intersection) / len(union)
def get_word_overlap_corpus(original_sentences, transferred_sentences):
results = []
for index in tqdm(range(len(original_sentences))):
results.append(get_word_overlap(original_sentences[index], transferred_sentences[index]))
return | np.mean(results) | numpy.mean |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import print_function
import torch
import numpy as np
import math
try:
from .chamfer_distance import ChamferDistance
except (ModuleNotFoundError, ImportError) as err:
from chamfer_distance import ChamferDistance
# Part of the code is referred from: https://github.com/WangYueFt/dcp, https://github.com/itailang/SampleNet,
# https://www.codegrepper.com/code-examples/python/Rotation+matrix+to+Euler+angles+Python.
def quat2mat(quat):
x, y, z, w = quat[:, 0], quat[:, 1], quat[:, 2], quat[:, 3]
B = quat.size(0)
w2, x2, y2, z2 = w.pow(2), x.pow(2), y.pow(2), z.pow(2)
wx, wy, wz = w*x, w*y, w*z
xy, xz, yz = x*y, x*z, y*z
rotMat = torch.stack([w2 + x2 - y2 - z2, 2*xy - 2*wz, 2*wy + 2*xz,
2*wz + 2*xy, w2 - x2 + y2 - z2, 2*yz - 2*wx,
2*xz - 2*wy, 2*wx + 2*yz, w2 - x2 - y2 + z2], dim=1).reshape(B, 3, 3)
return rotMat
def transform_point_cloud(point_cloud, rotation, translation):
return torch.matmul(rotation, point_cloud) + translation.unsqueeze(2)
def reverse_transform_point_cloud(point_cloud, rotation, translation):
return torch.matmul(rotation.permute(0, 2, 1).contiguous(), point_cloud - translation.unsqueeze(2))
def pca(pc, directions=None):
# A is of size B (batch) X n (features) X m (samples)
b, n, m = pc.shape
mass = torch.mean(pc, dim=2, keepdim=True)
pc = pc - mass
cov_pc = torch.matmul(pc, pc.permute(0, 2, 1).contiguous()) / (m - 1)
e, v = torch.symeig(cov_pc, eigenvectors=True)
if directions is not None:
signs = torch.sign(
torch.diagonal(torch.matmul(directions.permute(0, 2, 1).contiguous(), v), dim1=1, dim2=2)).unsqueeze(1)
v *= signs
return pc, v, mass
def invariant_coordinates_pca_chamfer(pc1, pc2):
pc1_centered, vecs1, mass1 = pca(pc1)
pc2_centered, vecs2, mass2 = pca(pc2)
batch_size = pc1.shape[0]
device = pc1.device
totensor = lambda vec: torch.tensor(vec, device=device)
quadrants = totensor([[1, 1, 1], [-1, -1, -1], [-1, 1, 1], [1, -1, 1],
[1, 1, -1], [-1, -1, 1], [1, -1, -1], [-1, 1, -1]])
def project(pc, axes):
if len(pc.shape) == 3:
return torch.matmul(axes.permute(0, 2, 1).contiguous(), pc)
if len(pc.shape) == 2:
return torch.matmul(axes.T, pc)
else:
assert 'pc shape length is either 2 or 3'
projected1 = project(pc1_centered, vecs1)
new_vecs2 = torch.zeros_like(vecs2)
projected2 = torch.zeros_like(pc2_centered)
quadrants_mats = torch.diag_embed(quadrants).type(torch.float).to(device)
for i in range(batch_size):
distances = []
for idx, option in enumerate(quadrants_mats):
distances.append(chamfer(projected1[i].unsqueeze(0),
project(pc2_centered[i], torch.matmul(vecs2[i], option)).unsqueeze(0))[0])
chosen_quadrant = torch.argmin(totensor(distances))
new_vecs2[i] = torch.matmul(vecs2[i], quadrants_mats[chosen_quadrant])
projected2[i] = project(pc2_centered[i], new_vecs2[i])
return projected1, vecs1, mass1, \
projected2, new_vecs2, mass2
def chamfer(pc1, pc2):
# ref_pc and samp_pc are B x N x 3 matrices
if pc1.shape[2] is not 3:
pc1 = pc1.permute(0, 2, 1).contiguous()
pc2 = pc2.permute(0, 2, 1).contiguous()
cost_pc1_pc2, cost_pc2_pc1 = ChamferDistance()(pc1, pc2)
max_cost = torch.mean(torch.max(cost_pc1_pc2, dim=1)[0] + torch.max(cost_pc2_pc1, dim=1)[0]) # furthest points
cost_pc1_pc2 = torch.mean(cost_pc1_pc2)
cost_pc2_pc1 = torch.mean(cost_pc2_pc1)
loss = cost_pc1_pc2 + cost_pc2_pc1
return loss, max_cost
def RRMSE(R_pred, R_gt):
R_pred_euler = npmat2euler_fullrange(R_pred.detach().cpu().numpy())
R_gt_euler = npmat2euler_fullrange(R_gt.detach().cpu().numpy())
return np.sqrt(np.mean((np.degrees(R_pred_euler) - | np.degrees(R_gt_euler) | numpy.degrees |
import pandas as pd
import numpy as np
import re
def del_null_str(str_list):
while '' in str_list:
str_list.remove('')
return str_list
def load_dataset(filename):
dataset = pd.read_csv('../data/'+filename+'.csv')
r = "[^a-z\s]+"
dataset.iloc[:, 0] = dataset.iloc[:, 0].apply(lambda x:
np.array(del_null_str(re.sub(r, '', x.strip().lower()).split(' '))))
return dataset
def create_words_set(dataset):
words = np.unique(np.hstack(dataset.iloc[:, 0]))
return words
def get_words_vector(words_set, input_words):
return np.in1d(words_set, input_words)
def train_bayes(dataset, words_set):
words_matrix = create_words_matrix(dataset, words_set)
normal_words_matrix = words_matrix[words_matrix.iloc[:, 1] == 'Normal_text']['Tweet']
abusive_words_matrix = words_matrix[words_matrix.iloc[:, 1] == 'bully_or_abusive_text']['Tweet']
normal_number = normal_words_matrix.shape[0]
sentence_number = words_matrix.shape[0]
p_normal = normal_number/sentence_number
sentence_number += 1
normal_vector = np.log((normal_words_matrix.apply(lambda x: x.astype(int)).sum() + 1)/sentence_number)
abusive_vector = np.log((abusive_words_matrix.apply(lambda x: x.astype(int)).sum() + 1) / sentence_number)
p_matrix = pd.DataFrame([normal_vector, abusive_vector], index=['normal', 'abusive'], columns=words_set)
return p_matrix, p_normal
def classify(vector, p_matrix, p_normal):
p_n = | np.sum(vector * p_matrix.iloc[0, :]) | numpy.sum |
import numpy as np
from torch.utils.data import Dataset, DataLoader
from torchvision.datasets import CIFAR10
import torchvision.transforms as transforms
from PIL import Image
from collections import defaultdict
import os
from tqdm import tqdm
from torchvision.datasets.folder import IMG_EXTENSIONS, has_file_allowed_extension
from typing import Tuple, List, Dict, Optional, Callable, cast
from .config import DATA_PATHS
from .utils import shuffle_sampler
class DigitsDataset(Dataset):
all_domains = ['MNIST', 'SVHN', 'USPS', 'SynthDigits', 'MNIST_M']
resorted_domains = {
0: ['MNIST', 'SVHN', 'USPS', 'SynthDigits', 'MNIST_M'],
1: ['SVHN', 'USPS', 'SynthDigits', 'MNIST_M', 'MNIST'],
2: ['USPS', 'SynthDigits', 'MNIST_M', 'MNIST', 'SVHN'],
3: ['SynthDigits', 'MNIST_M', 'MNIST', 'SVHN', 'USPS'],
4: ['MNIST_M', 'MNIST', 'SVHN', 'USPS', 'SynthDigits'],
}
num_classes = 10 # may not be correct
def __init__(self, domain, percent=0.1, filename=None, train=True, transform=None):
data_path = os.path.join(DATA_PATHS["Digits"], domain)
if filename is None:
if train:
if percent >= 0.1:
for part in range(int(percent*10)):
if part == 0:
self.images, self.labels = np.load(
os.path.join(data_path,
'partitions/train_part{}.pkl'.format(part)),
allow_pickle=True)
else:
images, labels = np.load(
os.path.join(data_path,
'partitions/train_part{}.pkl'.format(part)),
allow_pickle=True)
self.images = np.concatenate([self.images,images], axis=0)
self.labels = np.concatenate([self.labels,labels], axis=0)
else:
self.images, self.labels = np.load(
os.path.join(data_path, 'partitions/train_part0.pkl'),
allow_pickle=True)
data_len = int(self.images.shape[0] * percent*10)
self.images = self.images[:data_len]
self.labels = self.labels[:data_len]
else:
self.images, self.labels = np.load(os.path.join(data_path, 'test.pkl'),
allow_pickle=True)
else:
self.images, self.labels = np.load(os.path.join(data_path, filename),
allow_pickle=True)
self.transform = transform
self.channels = 3 if domain in ['SVHN', 'SynthDigits', 'MNIST_M'] else 1
self.labels = self.labels.astype(np.long).squeeze()
self.classes = np.unique(self.labels)
def __len__(self):
return self.images.shape[0]
def __getitem__(self, idx):
image = self.images[idx]
label = self.labels[idx]
if self.channels == 1:
image = Image.fromarray(image, mode='L')
elif self.channels == 3:
image = Image.fromarray(image, mode='RGB')
else:
raise ValueError("{} channel is not allowed.".format(self.channels))
if self.transform is not None:
image = self.transform(image)
return image, label
class CifarDataset(CIFAR10):
all_domains = ['cifar10']
resorted_domains = {
0: ['cifar10'],
}
num_classes = 10 # may not be correct
def __init__(self, domain='cifar10', train=True, transform=None, download=False):
assert domain in self.all_domains, f"Invalid domain: {domain}"
data_path = os.path.join(DATA_PATHS["Cifar10"], domain)
super().__init__(data_path, train=train, transform=transform, download=download)
class DomainNetDataset(Dataset):
all_domains = ['clipart', 'infograph', 'painting', 'quickdraw', 'real', 'sketch']
resorted_domains = {
0: ['real', 'clipart', 'infograph', 'painting', 'quickdraw', 'sketch'],
1: ['clipart', 'infograph', 'painting', 'quickdraw', 'sketch', 'real'],
2: ['infograph', 'painting', 'quickdraw', 'sketch', 'real', 'clipart'],
3: ['painting', 'quickdraw', 'sketch', 'real', 'clipart', 'infograph'],
4: ['quickdraw', 'sketch', 'real', 'clipart', 'infograph', 'painting'],
5: ['sketch', 'real', 'clipart', 'infograph', 'painting', 'quickdraw'],
}
num_classes = 10 # may not be correct
def __init__(self, site, train=True, transform=None, full_set=False):
self.full_set = full_set
self.base_path = DATA_PATHS['DomainNet']
if full_set:
classes, class_to_idx = find_classes(f"{self.base_path}/{site}")
self.text_labels = classes
self.paths, self.labels = make_dataset_from_dir(f"{self.base_path}/{site}",
class_to_idx, IMG_EXTENSIONS)
self.num_classes = len(class_to_idx)
else:
self.paths, self.text_labels = np.load('{}/DomainNet/{}_{}.pkl'.format(
DATA_PATHS['DomainNetPathList'],
site, 'train' if train else 'test'), allow_pickle=True)
class_to_idx = {'bird': 0, 'feather': 1, 'headphones': 2, 'ice_cream': 3, 'teapot': 4,
'tiger': 5, 'whale': 6, 'windmill': 7, 'wine_glass': 8, 'zebra': 9}
self.labels = [class_to_idx[text] for text in self.text_labels]
self.num_classes = len(class_to_idx)
self.transform = transform
self.classes = np.unique(self.labels)
def __len__(self):
return len(self.labels)
def __getitem__(self, idx):
site, cls, fname = self.paths[idx].split('/')[-3:]
img_path = os.path.join(self.base_path, site, cls, fname)
label = self.labels[idx]
image = Image.open(img_path)
if len(image.split()) != 3:
image = transforms.Grayscale(num_output_channels=3)(image)
if self.transform is not None:
image = self.transform(image)
return image, label
# //////////// Data processing ////////////
def find_classes(dir: str) -> Tuple[List[str], Dict[str, int]]:
"""
Finds the class folders in a dataset.
Args:
dir (string): Root directory path.
Returns:
tuple: (classes, class_to_idx) where classes are relative to (dir), and class_to_idx
is a dictionary.
Ensures:
No class is a subdirectory of another.
"""
classes = [d.name for d in os.scandir(dir) if d.is_dir()]
classes.sort()
class_to_idx = {cls_name: i for i, cls_name in enumerate(classes)}
return classes, class_to_idx
def make_dataset_from_dir(
directory: str,
class_to_idx: Dict[str, int],
extensions: Optional[Tuple[str, ...]] = None,
is_valid_file: Optional[Callable[[str], bool]] = None,
) -> Tuple[List[str], List[int]]:
"""Different Pytorch version, we return path and labels in two lists."""
paths, labels = [], []
directory = os.path.expanduser(directory)
both_none = extensions is None and is_valid_file is None
both_something = extensions is not None and is_valid_file is not None
if both_none or both_something:
raise ValueError("Both extensions and is_valid_file cannot be None or not None at the "
"same time")
if extensions is not None:
def is_valid_file(x: str) -> bool:
return has_file_allowed_extension(x, cast(Tuple[str, ...], extensions))
is_valid_file = cast(Callable[[str], bool], is_valid_file)
for target_class in sorted(class_to_idx.keys()):
class_index = class_to_idx[target_class]
target_dir = os.path.join(directory, target_class)
if not os.path.isdir(target_dir):
continue
for root, _, fnames in sorted(os.walk(target_dir, followlinks=True)):
for fname in sorted(fnames):
path = os.path.join(root, fname)
if is_valid_file(path):
paths.append(path)
labels.append(class_index)
return paths, labels
class Partitioner(object):
"""Class for partition a sequence into multiple shares (or users).
Args:
rng (np.random.RandomState): random state.
partition_mode (str): 'dir' for Dirichlet distribution or 'uni' for uniform.
max_n_sample_per_share (int): max number of samples per share.
min_n_sample_per_share (int): min number of samples per share.
max_n_sample (int): max number of samples
verbose (bool): verbosity
"""
def __init__(self, rng=None, partition_mode="dir",
max_n_sample_per_share=-1,
min_n_sample_per_share=2,
max_n_sample=-1,
verbose=True
):
assert max_n_sample_per_share < 0 or max_n_sample_per_share > min_n_sample_per_share, \
f"max ({max_n_sample_per_share}) > min ({min_n_sample_per_share})"
self.rng = rng if rng else np.random
self.partition_mode = partition_mode
self.max_n_sample_per_share = max_n_sample_per_share
self.min_n_sample_per_share = min_n_sample_per_share
self.max_n_sample = max_n_sample
self.verbose = verbose
def __call__(self, n_sample, n_share, log=print):
"""Partition a sequence of `n_sample` into `n_share` shares.
Returns:
partition: A list of num of samples for each share.
"""
assert n_share > 0, f"cannot split into {n_share} share"
if self.verbose:
log(f" {n_sample} smp => {n_share} shards by {self.partition_mode} distr")
if self.max_n_sample > 0:
n_sample = min((n_sample, self.max_n_sample))
if self.max_n_sample_per_share > 0:
n_sample = min((n_sample, n_share * self.max_n_sample_per_share))
if n_sample < self.min_n_sample_per_share * n_share:
raise ValueError(f"Not enough samples. Require {self.min_n_sample_per_share} samples"
f" per share at least for {n_share} shares. But only {n_sample} is"
f" available totally.")
n_sample -= self.min_n_sample_per_share * n_share
if self.partition_mode == "dir":
partition = (self.rng.dirichlet(n_share * [1]) * n_sample).astype(int)
elif self.partition_mode == "uni":
partition = int(n_sample // n_share) * np.ones(n_share, dtype='int')
else:
raise ValueError(f"Invalid partition_mode: {self.partition_mode}")
# uniformly add residual to as many users as possible.
for i in self.rng.choice(n_share, n_sample - np.sum(partition)):
partition[i] += 1
# partition[-1] += n_sample - np.sum(partition) # add residual
assert sum(partition) == n_sample, f"{sum(partition)} != {n_sample}"
partition = partition + self.min_n_sample_per_share
n_sample += self.min_n_sample_per_share * n_share
# partition = np.minimum(partition, max_n_sample_per_share)
partition = partition.tolist()
assert sum(partition) == n_sample, f"{sum(partition)} != {n_sample}"
assert len(partition) == n_share, f"{len(partition)} != {n_share}"
return partition
class ClassWisePartitioner(Partitioner):
"""Partition a list of labels by class. Classes will be shuffled and assigned to users
sequentially.
Args:
n_class_per_share (int): number of classes per share (user).
rng (np.random.RandomState): random state.
partition_mode (str): 'dir' for Dirichlet distribution or 'uni' for uniform.
max_n_sample_per_share (int): max number of samples per share.
min_n_sample_per_share (int): min number of samples per share.
max_n_sample (int): max number of samples
verbose (bool): verbosity
"""
def __init__(self, n_class_per_share=2, **kwargs):
super(ClassWisePartitioner, self).__init__(**kwargs)
self.n_class_per_share = n_class_per_share
self._aux_partitioner = Partitioner(**kwargs)
def __call__(self, labels, n_user, log=print, user_ids_by_class=None,
return_user_ids_by_class=False, consistent_class=False):
"""Partition a list of labels into `n_user` shares.
Returns:
partition: A list of users, where each user include a list of sample indexes.
"""
# reorganize labels by class
idx_by_class = defaultdict(list)
if len(labels) > 1e5:
labels_iter = tqdm(labels, leave=False, desc='sort labels')
else:
labels_iter = labels
for i, label in enumerate(labels_iter):
idx_by_class[label].append(i)
n_class = len(idx_by_class)
assert n_user * self.n_class_per_share > n_class, f"Cannot split {n_class} classes into " \
f"{n_user} users when each user only " \
f"has {self.n_class_per_share} classes."
# assign classes to each user.
if user_ids_by_class is None:
user_ids_by_class = defaultdict(list)
label_sampler = shuffle_sampler(list(range(n_class)),
self.rng if consistent_class else None)
for s in range(n_user):
s_classes = [label_sampler.next() for _ in range(self.n_class_per_share)]
for c in s_classes:
user_ids_by_class[c].append(s)
# assign sample indexes to clients
idx_by_user = [[] for _ in range(n_user)]
if n_class > 100 or len(labels) > 1e5:
idx_by_class_iter = tqdm(idx_by_class, leave=True, desc='split cls')
log = lambda log_s: idx_by_class_iter.set_postfix_str(log_s[:10]) # tqdm.write
else:
idx_by_class_iter = idx_by_class
for c in idx_by_class_iter:
l = len(idx_by_class[c])
log(f" class-{c} => {len(user_ids_by_class[c])} shares")
l_by_user = self._aux_partitioner(l, len(user_ids_by_class[c]), log=log)
base_idx = 0
for i_user, tl in zip(user_ids_by_class[c], l_by_user):
idx_by_user[i_user].extend(idx_by_class[c][base_idx:base_idx+tl])
base_idx += tl
if return_user_ids_by_class:
return idx_by_user, user_ids_by_class
else:
return idx_by_user
def extract_labels(dataset: Dataset):
if hasattr(dataset, 'targets'):
return dataset.targets
dl = DataLoader(dataset, batch_size=512, drop_last=False, num_workers=4, shuffle=False)
labels = []
dl_iter = tqdm(dl, leave=False, desc='load labels') if len(dl) > 100 else dl
for _, targets in dl_iter:
labels.extend(targets.cpu().numpy().tolist())
return labels
def test_class_partitioner():
print(f"\n==== Extract from random labels =====")
split = ClassWisePartitioner()
n_class = 10
n_sample = 1000
n_user = 100
labels = np.random.randint(0, n_class, n_sample)
idx_by_user = split(labels, n_user)
_n_smp = 0
for u in range(n_user):
u_labels = labels[idx_by_user[u]]
u_classes = | np.unique(u_labels) | numpy.unique |
import scine_utilities as su
import scine_molassembler as masm
import scine_database as db
import sys
import numpy as np
import random
import glob
from typing import Optional, Tuple, List, Iterable, Dict, Callable, Union
from functools import partial
from collections import defaultdict
from householding import Householder
"""
Overview
- Find Cp in each structure
- Substitute the Cp with something else
- Generate conformers
- First coordination sphere (excluding Cp and R) fixed, rest free
- Enough to sample Cp rotational freedom
"""
# Main variables to set up the structure generation
templatepath = "templates/UR.xyz"
newpath = "UR.xyz"
nconfs = 50
CENTRAL_ELEMENT = su.ElementType.Rh
# Approximate coordinates of the metal center in the template, useful to define clockwise/counterclockwise angles
ref_coords = [-1.5, -2, 0]
MaybePredicate = Optional[Callable[[su.AtomCollection], bool]]
# Indices to define either an angle (3 indices) or a dihedral (4 indices) to keep track of axial chirality. Can be None if not needed.
idxs = None # e.g. [31, 32, 33] # [6, 17, 18, 29]
# Direction can be True or False to switch the direction (axial chirality) of the attachment of the Cp
direction = True
# The SMILES in this string will be used to replace Cp in the template. Must contain a Cp-like structure.
func_smiles = (
"c12c[cH-]cc1[C@H](C)[C@H]3OC(c1ccccc1)(c1ccccc1)O[C@@H]3[C@@H]2(C)" # Catalyst 1
)
# Options to functionalize other positions of the Cp ring, in case the SMILES is not convenient
tip_smiles = None
tip_atom = su.ElementType.C
cindex_choice = 2
def is_flat_carbon(idx: int, mol: masm.Molecule) -> bool:
if mol.graph.element_type(idx) != su.ElementType.C:
return False
permutator = mol.stereopermutators.option(idx)
if not permutator:
return False
Shape = masm.shapes.Shape
flat_shapes = [Shape.Bent, Shape.EquilateralTriangle]
return permutator.shape in flat_shapes
def find_cyclopentadienyl(mol: masm.Molecule) -> Optional[List[int]]:
cp_pattern = masm.io.experimental.from_smiles("[C]1[C][C][C][C]1")
matches = masm.subgraphs.complete(cp_pattern, mol)
if len(matches) == 0:
return None
# There are likely to be multiple matches since the pattern is rotationally
# symmetric, so just pick the first one that works
for match in matches:
atoms = [j for i, j in match.left]
if all(map(partial(is_flat_carbon, mol=mol), atoms)):
return atoms
return None
class StableIndexManager:
"""
Allows you to keep using your atom indices while you're deleting atoms in a
molecule (which principally invalidates atom indices)
>>> manager = StableIndexManager()
>>> # Let's use partial, which doesn't raise on reusing deleted indices
>>> [manager.partial(i) for i in range(8)]
[0, 1, 2, 3, 4, 5, 6, 7]
>>> manager.delete(4)
>>> [manager.partial(i) for i in range(8)]
[0, 1, 2, 3, None, 4, 5, 6]
>>> manager.delete(2)
>>> [manager.partial(i) for i in range(8)]
[0, 1, None, 2, None, 3, 4, 5]
"""
deleted_indices: List[int]
def __init__(self):
self.deleted_indices = []
def __call__(self, index: int) -> int:
result = index
for i in self.deleted_indices:
if i == index:
raise RuntimeError("This atom was deleted!")
if result > i:
result -= 1
return result
def partial(self, index: int) -> Optional[int]:
try:
return self(index)
except RuntimeError:
return None
def delete(self, index: int):
self.deleted_indices.append(index)
self.deleted_indices.sort(reverse=True)
def find_cyclopentadienyl_site(mol: masm.Molecule) -> Optional[Tuple[int, int]]:
"""Returns atom index and site index pair"""
flat_carbon = partial(is_flat_carbon, mol=mol)
for permutator in mol.stereopermutators.atom_stereopermutators():
for site_idx, site in enumerate(permutator.ranking.sites):
if len(site) == 5 and all(map(flat_carbon, site)):
return (permutator.placement, site_idx)
return None
class Pseudodihedral:
"""Class for calculating rotation of a substituted cyclopentadienyl"""
Sequence = List[Union[int, List[int]]]
definition: Sequence
def __init__(self, mol: masm.Molecule):
"""Find a working definition of the pseudodihedral"""
maybe_atom_site_pair = find_cyclopentadienyl_site(mol)
if not maybe_atom_site_pair:
raise RuntimeError("Couldn't find Cp for pseudodihedral")
second, cyclopentadienyl_site = maybe_atom_site_pair
ranking = mol.stereopermutators[second].ranking
sites = ranking.sites
ranked_substituents = ranking.ranked_substituents
# Select the first fixture as the lowest ranked non-haptic site atom
lowest_ranked_nonhaptic_sites = [
equivalent_sites[0]
for equivalent_sites in ranking.ranked_sites
if len(equivalent_sites) == 1 and len(sites[equivalent_sites[0]]) == 1
]
assert len(lowest_ranked_nonhaptic_sites) > 0
first = sites[lowest_ranked_nonhaptic_sites[0]][0]
third = sites[cyclopentadienyl_site]
# Select the highest ranked unique substituent in the haptic site
def atom_rank(atom: int) -> int:
for i, equivalent_atom_list in enumerate(ranked_substituents):
if atom in equivalent_atom_list:
return i
raise IndexError(f"No atom {atom} in ranked substituents")
ranks: Dict[int, List[int]] = defaultdict(list)
for atom in third:
ranks[atom_rank(atom)].append(atom)
rank_descending = sorted(ranks.items(), reverse=True)
uniques = [atoms[0] for rank, atoms in rank_descending if len(atoms) == 1]
if len(uniques) == 0:
raise RuntimeError("No uniquely ranked atom in haptic site")
fourth = uniques[0]
self.definition = [first, second, third, fourth]
def __call__(self, ac: su.AtomCollection) -> float:
"""Returns a calculated dihedral in radians in [-pi, pi)"""
def average(ac: su.AtomCollection, x: Union[int, List[int]]) -> np.ndarray:
if isinstance(x, int):
return ac.get_position(x)
return sum([ac.get_position(i) for i in x]) / len(x)
m = np.array([average(ac, atom_or_list) for atom_or_list in self.definition])
return Pseudodihedral.dihedral_angle(m)
@staticmethod
def dihedral_angle(p: np.ndarray) -> float:
"""Calculates the dihedral between four points"""
b0 = -1.0 * (p[1] - p[0])
b1 = p[2] - p[1]
b2 = p[3] - p[2]
b1 /= np.linalg.norm(b1)
v = b0 - np.dot(b0, b1) * b1
w = b2 - np.dot(b2, b1) * b1
x = np.dot(v, w)
y = np.dot(np.cross(b1, v), w)
return np.arctan2(y, x)
@staticmethod
def normal_angle(p: np.ndarray, ref: np.ndarray) -> float:
"""Calculates the angle between three points"""
b0 = p[0] - p[1]
b1 = p[2] - p[1]
b0 /= np.linalg.norm(b0)
b1 /= np.linalg.norm(b1)
x = np.dot(b0, b1)
w = ref - p[1]
w /= np.linalg.norm(w)
y = np.dot(w, np.cross(b0, b1))
a = | np.arctan2(y, x) | numpy.arctan2 |
import numpy as np
def exp_running_avg(running, new, gamma=.9):
return gamma * running + (1. - gamma) * new
def accuracy(y_true, y_pred):
return | np.mean(y_pred == y_true) | numpy.mean |
import os
import numpy as np
import hyperspy.api as hs
from pyiron_base._tests import TestWithCleanProject
import pyiron_experimental
class TestHSLineProfiles(TestWithCleanProject):
@classmethod
def setUpClass(cls):
super().setUpClass()
data = hs.load(os.path.join(cls.project.path, '../../notebooks/experiment.emd'))
cls.signal = data[0]
def setUp(self):
self.job = self.project.create.job.HSLineProfiles('tem')
def test_set_signal(self):
signal = self.signal
with self.subTest('No hs signal'):
with self.assertRaises(ValueError):
self.job.signal = None
with self.subTest('intended use case'):
self.job.signal = signal
self.assertEqual(self.job.input.signal.hs_class_name, 'Signal2D')
self.assertEqual(self.job.input.signal.axes, list(signal.axes_manager.as_dictionary().values()))
self.assertTrue(np.array_equal(self.job.input.signal.data, signal.data))
self.assertDictEqual(self.job.input.signal.metadata, signal.metadata.as_dictionary())
self.assertDictEqual(self.job.input.signal.original_metadata, signal.original_metadata.as_dictionary())
with self.subTest('already running'):
self.job.status.running = True
with self.assertRaises(RuntimeError):
self.job.signal = signal
def test_hs(self):
data = self.job.hs.load(os.path.join(self.project.path, '../../notebooks/experiment.emd'))
self.assertEqual(data[0], self.signal)
def test_static_workflow(self):
self.job.signal = self.signal
self.job.input.x = [[0, 50], [50, 50]]
self.job.input.y = [[10, 10], [0, 50]]
self.job.run()
self.assertEqual(len(self.job.output), 2)
with self.subTest('Output line 0'):
output = self.job.output[0]
self.assertEqual(output['line'], 0)
self.assertTrue(np.array_equal(output['x'], [0, 50]), msg=f"Expected {[0, 50]} but got {output['x']}.")
self.assertTrue(np.array_equal(output['y'], [10, 10]), msg=f"Expected {[10, 10]} but got {output['y']}.")
self.assertAlmostEqual(np.sum(output['data']), 1577323.2)
with self.subTest('Output line 1'):
output = self.job.output[1]
self.assertEqual(output['line'], 1)
self.assertTrue(np.array_equal(output['x'], [50, 50]), msg=f"Expected {[50, 50]} but got {output['x']}.")
self.assertTrue(np.array_equal(output['y'], [0, 50]), msg=f"Expected {[0, 50]} but got {output['y']}.")
self.assertAlmostEqual(np.sum(output['data']), 1509104.4)
def test_interactive_workflow(self):
self.job.signal = self.signal
self.job._useblit = False
fig = self.job.plot_signal()
fig.show()
self.job.add_line(x=[0, 50], y=[10, 10])
self.job.plot_line_profiles()
with self.subTest('Output line 0'):
output = self.job.output[0]
self.assertEqual(output['line'], 0)
self.assertTrue(np.array_equal(output['x'], [0, 50]), msg=f"Expected {[0, 50]} but got {output['x']}.")
self.assertTrue(np.array_equal(output['y'], [10, 10]), msg=f"Expected {[10, 10]} but got {output['y']}.")
self.assertAlmostEqual(np.sum(output['data']), 1577323.2)
self.job.add_line(x=[50, 50], y=[0, 50])
self.job.plot_line_profiles()
with self.subTest('Output line 1'):
output = self.job.output[1]
self.assertEqual(output['line'], 0)
self.assertTrue(np.array_equal(output['x'], [0, 50]), msg=f"Expected {[0, 50]} but got {output['x']}.")
self.assertTrue(np.array_equal(output['y'], [10, 10]), msg=f"Expected {[10, 10]} but got {output['y']}.")
self.assertAlmostEqual(np.sum(output['data']), 1577323.2)
with self.subTest('Output line 2'):
output = self.job.output[2]
self.assertEqual(output['line'], 1)
self.assertTrue(np.array_equal(output['x'], [50, 50]), msg=f"Expected {[50, 50]} but got {output['x']}.")
self.assertTrue(np.array_equal(output['y'], [0, 50]), msg=f"Expected {[0, 50]} but got {output['y']}.")
self.assertAlmostEqual(np.sum(output['data']), 1509104.4)
def test_load_static_workflow(self):
self.test_static_workflow()
job = self.project.load('tem')
self.assertEqual(job.signal, self.signal)
with self.subTest('Output line 0'):
output = job.output[0]
self.assertEqual(output['line'], 0)
self.assertTrue(np.array_equal(output['x'], [0, 50]), msg=f"Expected {[0, 50]} but got {output['x']}.")
self.assertTrue(np.array_equal(output['y'], [10, 10]), msg=f"Expected {[10, 10]} but got {output['y']}.")
self.assertAlmostEqual(np.sum(output['data']), 1577323.2)
with self.subTest('Output line 1'):
output = job.output[1]
self.assertEqual(output['line'], 1)
self.assertTrue(np.array_equal(output['x'], [50, 50]), msg=f"Expected {[50, 50]} but got {output['x']}.")
self.assertTrue(np.array_equal(output['y'], [0, 50]), msg=f"Expected {[0, 50]} but got {output['y']}.")
self.assertAlmostEqual(np.sum(output['data']), 1509104.4)
def test_load_interactive_workflow(self):
self.test_interactive_workflow()
job = self.project.load('tem')
self.assertEqual(job.signal, self.signal)
with self.subTest('Output line 0'):
output = job.output[0]
self.assertEqual(output['line'], 0)
self.assertTrue(np.array_equal(output['x'], [0, 50]), msg=f"Expected {[0, 50]} but got {output['x']}.")
self.assertTrue(np.array_equal(output['y'], [10, 10]), msg=f"Expected {[10, 10]} but got {output['y']}.")
self.assertAlmostEqual(np.sum(output['data']), 1577323.2)
with self.subTest('Output line 1'):
output = job.output[1]
self.assertEqual(output['line'], 0)
self.assertTrue(np.array_equal(output['x'], [0, 50]), msg=f"Expected {[0, 50]} but got {output['x']}.")
self.assertTrue(np.array_equal(output['y'], [10, 10]), msg=f"Expected {[10, 10]} but got {output['y']}.")
self.assertAlmostEqual( | np.sum(output['data']) | numpy.sum |
# Copyright (c) 2017,2018 MetPy Developers.
# Distributed under the terms of the BSD 3-Clause License.
# SPDX-License-Identifier: BSD-3-Clause
"""Tests for the `_util` module."""
from datetime import datetime
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import pytest
from metpy.plots import add_metpy_logo, add_timestamp, add_unidata_logo, convert_gempak_color
# Fixture to make sure we have the right backend
from metpy.testing import set_agg_backend # noqa: F401, I202
MPL_VERSION = matplotlib.__version__[:3]
@pytest.mark.mpl_image_compare(tolerance=2.638, remove_text=True)
def test_add_timestamp():
"""Test adding a timestamp to an axes object."""
fig = plt.figure(figsize=(9, 9))
ax = plt.subplot(1, 1, 1)
add_timestamp(ax, time=datetime(2017, 1, 1))
return fig
@pytest.mark.mpl_image_compare(tolerance=2.635, remove_text=True)
def test_add_timestamp_custom_format():
"""Test adding a timestamp to an axes object with custom time formatting."""
fig = plt.figure(figsize=(9, 9))
ax = plt.subplot(1, 1, 1)
add_timestamp(ax, time=datetime(2017, 1, 1), time_format='%H:%M:%S %Y/%m/%d')
return fig
@pytest.mark.mpl_image_compare(tolerance=5.389, remove_text=True)
def test_add_timestamp_pretext():
"""Test adding a timestamp to an axes object with custom pre-text."""
fig = plt.figure(figsize=(9, 9))
ax = plt.subplot(1, 1, 1)
add_timestamp(ax, time=datetime(2017, 1, 1), pretext='Valid: ')
return fig
@pytest.mark.mpl_image_compare(tolerance=0.844, remove_text=True)
def test_add_timestamp_high_contrast():
"""Test adding a timestamp to an axes object."""
fig = plt.figure(figsize=(9, 9))
ax = plt.subplot(1, 1, 1)
add_timestamp(ax, time=datetime(2017, 1, 1), high_contrast=True)
return fig
@pytest.mark.mpl_image_compare(tolerance=0.004, remove_text=True)
def test_add_metpy_logo_small():
"""Test adding a MetPy logo to a figure."""
fig = plt.figure(figsize=(9, 9))
add_metpy_logo(fig)
return fig
@pytest.mark.mpl_image_compare(tolerance=0.004, remove_text=True)
def test_add_metpy_logo_large():
"""Test adding a large MetPy logo to a figure."""
fig = plt.figure(figsize=(9, 9))
add_metpy_logo(fig, size='large')
return fig
@pytest.mark.mpl_image_compare(tolerance=0.004, remove_text=True)
def test_add_unidata_logo():
"""Test adding a Unidata logo to a figure."""
fig = plt.figure(figsize=(9, 9))
add_unidata_logo(fig)
return fig
def test_add_logo_invalid_size():
"""Test adding a logo to a figure with an invalid size specification."""
fig = plt.figure(figsize=(9, 9))
with pytest.raises(ValueError):
add_metpy_logo(fig, size='jumbo')
@pytest.mark.mpl_image_compare(tolerance={'3.0': 1.072}.get(MPL_VERSION, 0),
remove_text=True)
def test_gempak_color_image_compare():
"""Test creating a plot with all the GEMPAK colors."""
c = range(32)
mplc = convert_gempak_color(c)
delta = 0.025
x = y = np.arange(-3.0, 3.01, delta)
xx, yy = | np.meshgrid(x, y) | numpy.meshgrid |
import numpy as np
from pyray.shapes.twod.paraboloid import *
from pyray.shapes.twod.functional import *
from pyray.rotation import *
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import matplotlib as mpl
import os
basedir = '.\\Images\\RotatingCube\\'
if os.name == 'posix':
basedir = 'Images/RotatingCube/'
def draw_cubic():
fn = lambda x,y: x**3+y**3
for i in range(20):
im = Image.new("RGB", (2048, 2048), "black")
draw = ImageDraw.Draw(im, 'RGBA')
r = general_rotation(np.array([1,0,0]),np.pi/120*i)
#drawFunctionalXYGridInCircle(draw, r, fn=fn, scale=10.0)
im.save(basedir + 'im' + str(i) + '.png')
def three_d_grid():
fig = plt.figure()
ax = fig.gca(projection='3d')
# Make data.
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
R = (X**3 + Y**3)
Z = R
# Plot the surface.
surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm,
linewidth=0, antialiased=False)
# Customize the z axis.
#ax.set_zlim(-1.01, 1.01)
#ax.zaxis.set_major_locator(LinearLocator(10))
#ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
# Add a color bar which maps values to colors.
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show()
mpl.rcParams['legend.fontsize'] = 10
fig = plt.figure()
ax = fig.gca(projection='3d')
theta = np.linspace(0, 2 * np.pi, 100)
for r in np.arange(0.1,1.0,0.1):
#r = 1.0
x = r * np.sin(theta)
y = r * np.cos(theta)
z = x**3+y**3
ax.plot(x, y, z, label='parametric curve')
#ax.legend()
plt.show()
def paraboloid_w_grad(im_ind=0, scale=200, shift=np.array([1000,1000,0]), opacity=60,
basepath='.\\'):
r1 = np.eye(4)
rot = general_rotation(np.array([0,0,1]), np.pi/20.0 * (8 + im_ind/3.0))
j=4
r = rotation(3, 2 * np.pi* j /30.0)
rr = general_rotation(np.array([0,1,0]), np.pi/20.0 * (im_ind/7.0))
r = np.dot(r,rr)
r = np.dot(r, rot)
r1[:3,:3] = r
im = Image.new("RGB", (2048, 2048), "black")
draw = ImageDraw.Draw(im, 'RGBA')
render_scene_4d_axis(draw, r1, 4, scale, shift)
# This is what draws the pink paraboloid.
for z in np.arange(0.001, 3.5, 0.02):
point1 = np.array([np.sqrt(z),0,z])
generalized_arc(draw, r, center=np.array([0,0,z]), vec=np.array([0,0,1]),
point=point1, radius=np.sqrt(z), prcnt=1.0,
rgba=(255,20,147,50))
xax1=np.array([-100.0,0,0.0]);xax1=np.dot(r,xax1)*scale+shift
xax2=np.array([100.0,0,0.0]);xax2=np.dot(r,xax2)*scale+shift
draw.line((xax1[0], xax1[1], xax2[0], xax2[1]), fill=(255,255,0), width=4)
xax1=np.array([0.0,-100,0.0]);xax1=np.dot(r,xax1)*scale+shift
xax2=np.array([0.0,100,0.0]);xax2=np.dot(r,xax2)*scale+shift
draw.line((xax1[0], xax1[1], xax2[0], xax2[1]), fill=(255,255,0), width=4)
#gradients(draw,r)
pt = shift
draw.ellipse((pt[0]-10, pt[1]-10, pt[0]+10, pt[1]+10), fill = (0,255,0))
draw_paraboloid_plane(draw,r,3.3)
draw_paraboloid_plane(draw,r,2.0,extent=1.4)
draw_paraboloid_plane(draw,r,1.0,extent=1.0)
im.save(basepath + 'im' + str(im_ind) + '.png')
def gradients(draw,r):
#for z in [0.3,1.3,2.3,3.3]:
for z in [3.3,2.0,1.0]:
x = np.sqrt(z)
for x in np.arange(-x,x,x/2):
y = | np.sqrt(z-x*x) | numpy.sqrt |
""" Test functions for linalg module
"""
import os
import sys
import itertools
import traceback
import textwrap
import subprocess
import pytest
import numpy as np
from numpy import array, single, double, csingle, cdouble, dot, identity, matmul
from numpy import multiply, atleast_2d, inf, asarray
from numpy import linalg
from numpy.linalg import matrix_power, norm, matrix_rank, multi_dot, LinAlgError
from numpy.linalg.linalg import _multi_dot_matrix_chain_order
from numpy.testing import (
assert_, assert_equal, assert_raises, assert_array_equal,
assert_almost_equal, assert_allclose, suppress_warnings,
assert_raises_regex, HAS_LAPACK64,
)
from numpy.testing._private.utils import requires_memory
def consistent_subclass(out, in_):
# For ndarray subclass input, our output should have the same subclass
# (non-ndarray input gets converted to ndarray).
return type(out) is (type(in_) if isinstance(in_, np.ndarray)
else np.ndarray)
old_assert_almost_equal = assert_almost_equal
def assert_almost_equal(a, b, single_decimal=6, double_decimal=12, **kw):
if asarray(a).dtype.type in (single, csingle):
decimal = single_decimal
else:
decimal = double_decimal
old_assert_almost_equal(a, b, decimal=decimal, **kw)
def get_real_dtype(dtype):
return {single: single, double: double,
csingle: single, cdouble: double}[dtype]
def get_complex_dtype(dtype):
return {single: csingle, double: cdouble,
csingle: csingle, cdouble: cdouble}[dtype]
def get_rtol(dtype):
# Choose a safe rtol
if dtype in (single, csingle):
return 1e-5
else:
return 1e-11
# used to categorize tests
all_tags = {
'square', 'nonsquare', 'hermitian', # mutually exclusive
'generalized', 'size-0', 'strided' # optional additions
}
class LinalgCase:
def __init__(self, name, a, b, tags=set()):
"""
A bundle of arguments to be passed to a test case, with an identifying
name, the operands a and b, and a set of tags to filter the tests
"""
assert_(isinstance(name, str))
self.name = name
self.a = a
self.b = b
self.tags = frozenset(tags) # prevent shared tags
def check(self, do):
"""
Run the function `do` on this test case, expanding arguments
"""
do(self.a, self.b, tags=self.tags)
def __repr__(self):
return f'<LinalgCase: {self.name}>'
def apply_tag(tag, cases):
"""
Add the given tag (a string) to each of the cases (a list of LinalgCase
objects)
"""
assert tag in all_tags, "Invalid tag"
for case in cases:
case.tags = case.tags | {tag}
return cases
#
# Base test cases
#
np.random.seed(1234)
CASES = []
# square test cases
CASES += apply_tag('square', [
LinalgCase("single",
array([[1., 2.], [3., 4.]], dtype=single),
array([2., 1.], dtype=single)),
LinalgCase("double",
array([[1., 2.], [3., 4.]], dtype=double),
array([2., 1.], dtype=double)),
LinalgCase("double_2",
array([[1., 2.], [3., 4.]], dtype=double),
array([[2., 1., 4.], [3., 4., 6.]], dtype=double)),
LinalgCase("csingle",
array([[1. + 2j, 2 + 3j], [3 + 4j, 4 + 5j]], dtype=csingle),
array([2. + 1j, 1. + 2j], dtype=csingle)),
LinalgCase("cdouble",
array([[1. + 2j, 2 + 3j], [3 + 4j, 4 + 5j]], dtype=cdouble),
array([2. + 1j, 1. + 2j], dtype=cdouble)),
LinalgCase("cdouble_2",
array([[1. + 2j, 2 + 3j], [3 + 4j, 4 + 5j]], dtype=cdouble),
array([[2. + 1j, 1. + 2j, 1 + 3j], [1 - 2j, 1 - 3j, 1 - 6j]], dtype=cdouble)),
LinalgCase("0x0",
np.empty((0, 0), dtype=double),
np.empty((0,), dtype=double),
tags={'size-0'}),
LinalgCase("8x8",
np.random.rand(8, 8),
np.random.rand(8)),
LinalgCase("1x1",
np.random.rand(1, 1),
np.random.rand(1)),
LinalgCase("nonarray",
[[1, 2], [3, 4]],
[2, 1]),
])
# non-square test-cases
CASES += apply_tag('nonsquare', [
LinalgCase("single_nsq_1",
array([[1., 2., 3.], [3., 4., 6.]], dtype=single),
array([2., 1.], dtype=single)),
LinalgCase("single_nsq_2",
array([[1., 2.], [3., 4.], [5., 6.]], dtype=single),
array([2., 1., 3.], dtype=single)),
LinalgCase("double_nsq_1",
array([[1., 2., 3.], [3., 4., 6.]], dtype=double),
array([2., 1.], dtype=double)),
LinalgCase("double_nsq_2",
array([[1., 2.], [3., 4.], [5., 6.]], dtype=double),
array([2., 1., 3.], dtype=double)),
LinalgCase("csingle_nsq_1",
array(
[[1. + 1j, 2. + 2j, 3. - 3j], [3. - 5j, 4. + 9j, 6. + 2j]], dtype=csingle),
array([2. + 1j, 1. + 2j], dtype=csingle)),
LinalgCase("csingle_nsq_2",
array(
[[1. + 1j, 2. + 2j], [3. - 3j, 4. - 9j], [5. - 4j, 6. + 8j]], dtype=csingle),
array([2. + 1j, 1. + 2j, 3. - 3j], dtype=csingle)),
LinalgCase("cdouble_nsq_1",
array(
[[1. + 1j, 2. + 2j, 3. - 3j], [3. - 5j, 4. + 9j, 6. + 2j]], dtype=cdouble),
array([2. + 1j, 1. + 2j], dtype=cdouble)),
LinalgCase("cdouble_nsq_2",
array(
[[1. + 1j, 2. + 2j], [3. - 3j, 4. - 9j], [5. - 4j, 6. + 8j]], dtype=cdouble),
array([2. + 1j, 1. + 2j, 3. - 3j], dtype=cdouble)),
LinalgCase("cdouble_nsq_1_2",
array(
[[1. + 1j, 2. + 2j, 3. - 3j], [3. - 5j, 4. + 9j, 6. + 2j]], dtype=cdouble),
array([[2. + 1j, 1. + 2j], [1 - 1j, 2 - 2j]], dtype=cdouble)),
LinalgCase("cdouble_nsq_2_2",
array(
[[1. + 1j, 2. + 2j], [3. - 3j, 4. - 9j], [5. - 4j, 6. + 8j]], dtype=cdouble),
array([[2. + 1j, 1. + 2j], [1 - 1j, 2 - 2j], [1 - 1j, 2 - 2j]], dtype=cdouble)),
LinalgCase("8x11",
np.random.rand(8, 11),
np.random.rand(8)),
LinalgCase("1x5",
np.random.rand(1, 5),
np.random.rand(1)),
LinalgCase("5x1",
np.random.rand(5, 1),
np.random.rand(5)),
LinalgCase("0x4",
np.random.rand(0, 4),
np.random.rand(0),
tags={'size-0'}),
LinalgCase("4x0",
np.random.rand(4, 0),
np.random.rand(4),
tags={'size-0'}),
])
# hermitian test-cases
CASES += apply_tag('hermitian', [
LinalgCase("hsingle",
array([[1., 2.], [2., 1.]], dtype=single),
None),
LinalgCase("hdouble",
array([[1., 2.], [2., 1.]], dtype=double),
None),
LinalgCase("hcsingle",
array([[1., 2 + 3j], [2 - 3j, 1]], dtype=csingle),
None),
LinalgCase("hcdouble",
array([[1., 2 + 3j], [2 - 3j, 1]], dtype=cdouble),
None),
LinalgCase("hempty",
np.empty((0, 0), dtype=double),
None,
tags={'size-0'}),
LinalgCase("hnonarray",
[[1, 2], [2, 1]],
None),
LinalgCase("matrix_b_only",
array([[1., 2.], [2., 1.]]),
None),
LinalgCase("hmatrix_1x1",
np.random.rand(1, 1),
None),
])
#
# Gufunc test cases
#
def _make_generalized_cases():
new_cases = []
for case in CASES:
if not isinstance(case.a, np.ndarray):
continue
a = np.array([case.a, 2 * case.a, 3 * case.a])
if case.b is None:
b = None
else:
b = np.array([case.b, 7 * case.b, 6 * case.b])
new_case = LinalgCase(case.name + "_tile3", a, b,
tags=case.tags | {'generalized'})
new_cases.append(new_case)
a = np.array([case.a] * 2 * 3).reshape((3, 2) + case.a.shape)
if case.b is None:
b = None
else:
b = np.array([case.b] * 2 * 3).reshape((3, 2) + case.b.shape)
new_case = LinalgCase(case.name + "_tile213", a, b,
tags=case.tags | {'generalized'})
new_cases.append(new_case)
return new_cases
CASES += _make_generalized_cases()
#
# Generate stride combination variations of the above
#
def _stride_comb_iter(x):
"""
Generate cartesian product of strides for all axes
"""
if not isinstance(x, np.ndarray):
yield x, "nop"
return
stride_set = [(1,)] * x.ndim
stride_set[-1] = (1, 3, -4)
if x.ndim > 1:
stride_set[-2] = (1, 3, -4)
if x.ndim > 2:
stride_set[-3] = (1, -4)
for repeats in itertools.product(*tuple(stride_set)):
new_shape = [abs(a * b) for a, b in zip(x.shape, repeats)]
slices = tuple([slice(None, None, repeat) for repeat in repeats])
# new array with different strides, but same data
xi = np.empty(new_shape, dtype=x.dtype)
xi.view(np.uint32).fill(0xdeadbeef)
xi = xi[slices]
xi[...] = x
xi = xi.view(x.__class__)
assert_(np.all(xi == x))
yield xi, "stride_" + "_".join(["%+d" % j for j in repeats])
# generate also zero strides if possible
if x.ndim >= 1 and x.shape[-1] == 1:
s = list(x.strides)
s[-1] = 0
xi = np.lib.stride_tricks.as_strided(x, strides=s)
yield xi, "stride_xxx_0"
if x.ndim >= 2 and x.shape[-2] == 1:
s = list(x.strides)
s[-2] = 0
xi = np.lib.stride_tricks.as_strided(x, strides=s)
yield xi, "stride_xxx_0_x"
if x.ndim >= 2 and x.shape[:-2] == (1, 1):
s = list(x.strides)
s[-1] = 0
s[-2] = 0
xi = np.lib.stride_tricks.as_strided(x, strides=s)
yield xi, "stride_xxx_0_0"
def _make_strided_cases():
new_cases = []
for case in CASES:
for a, a_label in _stride_comb_iter(case.a):
for b, b_label in _stride_comb_iter(case.b):
new_case = LinalgCase(case.name + "_" + a_label + "_" + b_label, a, b,
tags=case.tags | {'strided'})
new_cases.append(new_case)
return new_cases
CASES += _make_strided_cases()
#
# Test different routines against the above cases
#
class LinalgTestCase:
TEST_CASES = CASES
def check_cases(self, require=set(), exclude=set()):
"""
Run func on each of the cases with all of the tags in require, and none
of the tags in exclude
"""
for case in self.TEST_CASES:
# filter by require and exclude
if case.tags & require != require:
continue
if case.tags & exclude:
continue
try:
case.check(self.do)
except Exception as e:
msg = f'In test case: {case!r}\n\n'
msg += traceback.format_exc()
raise AssertionError(msg) from e
class LinalgSquareTestCase(LinalgTestCase):
def test_sq_cases(self):
self.check_cases(require={'square'},
exclude={'generalized', 'size-0'})
def test_empty_sq_cases(self):
self.check_cases(require={'square', 'size-0'},
exclude={'generalized'})
class LinalgNonsquareTestCase(LinalgTestCase):
def test_nonsq_cases(self):
self.check_cases(require={'nonsquare'},
exclude={'generalized', 'size-0'})
def test_empty_nonsq_cases(self):
self.check_cases(require={'nonsquare', 'size-0'},
exclude={'generalized'})
class HermitianTestCase(LinalgTestCase):
def test_herm_cases(self):
self.check_cases(require={'hermitian'},
exclude={'generalized', 'size-0'})
def test_empty_herm_cases(self):
self.check_cases(require={'hermitian', 'size-0'},
exclude={'generalized'})
class LinalgGeneralizedSquareTestCase(LinalgTestCase):
@pytest.mark.slow
def test_generalized_sq_cases(self):
self.check_cases(require={'generalized', 'square'},
exclude={'size-0'})
@pytest.mark.slow
def test_generalized_empty_sq_cases(self):
self.check_cases(require={'generalized', 'square', 'size-0'})
class LinalgGeneralizedNonsquareTestCase(LinalgTestCase):
@pytest.mark.slow
def test_generalized_nonsq_cases(self):
self.check_cases(require={'generalized', 'nonsquare'},
exclude={'size-0'})
@pytest.mark.slow
def test_generalized_empty_nonsq_cases(self):
self.check_cases(require={'generalized', 'nonsquare', 'size-0'})
class HermitianGeneralizedTestCase(LinalgTestCase):
@pytest.mark.slow
def test_generalized_herm_cases(self):
self.check_cases(require={'generalized', 'hermitian'},
exclude={'size-0'})
@pytest.mark.slow
def test_generalized_empty_herm_cases(self):
self.check_cases(require={'generalized', 'hermitian', 'size-0'},
exclude={'none'})
def dot_generalized(a, b):
a = asarray(a)
if a.ndim >= 3:
if a.ndim == b.ndim:
# matrix x matrix
new_shape = a.shape[:-1] + b.shape[-1:]
elif a.ndim == b.ndim + 1:
# matrix x vector
new_shape = a.shape[:-1]
else:
raise ValueError("Not implemented...")
r = np.empty(new_shape, dtype=np.common_type(a, b))
for c in itertools.product(*map(range, a.shape[:-2])):
r[c] = dot(a[c], b[c])
return r
else:
return dot(a, b)
def identity_like_generalized(a):
a = asarray(a)
if a.ndim >= 3:
r = np.empty(a.shape, dtype=a.dtype)
r[...] = identity(a.shape[-2])
return r
else:
return identity(a.shape[0])
class SolveCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
# kept apart from TestSolve for use for testing with matrices.
def do(self, a, b, tags):
x = linalg.solve(a, b)
assert_almost_equal(b, dot_generalized(a, x))
assert_(consistent_subclass(x, b))
class TestSolve(SolveCases):
@pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
def test_types(self, dtype):
x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype)
assert_equal(linalg.solve(x, x).dtype, dtype)
def test_0_size(self):
class ArraySubclass(np.ndarray):
pass
# Test system of 0x0 matrices
a = np.arange(8).reshape(2, 2, 2)
b = np.arange(6).reshape(1, 2, 3).view(ArraySubclass)
expected = linalg.solve(a, b)[:, 0:0, :]
result = linalg.solve(a[:, 0:0, 0:0], b[:, 0:0, :])
assert_array_equal(result, expected)
assert_(isinstance(result, ArraySubclass))
# Test errors for non-square and only b's dimension being 0
assert_raises(linalg.LinAlgError, linalg.solve, a[:, 0:0, 0:1], b)
assert_raises(ValueError, linalg.solve, a, b[:, 0:0, :])
# Test broadcasting error
b = np.arange(6).reshape(1, 3, 2) # broadcasting error
assert_raises(ValueError, linalg.solve, a, b)
assert_raises(ValueError, linalg.solve, a[0:0], b[0:0])
# Test zero "single equations" with 0x0 matrices.
b = np.arange(2).reshape(1, 2).view(ArraySubclass)
expected = linalg.solve(a, b)[:, 0:0]
result = linalg.solve(a[:, 0:0, 0:0], b[:, 0:0])
assert_array_equal(result, expected)
assert_(isinstance(result, ArraySubclass))
b = np.arange(3).reshape(1, 3)
assert_raises(ValueError, linalg.solve, a, b)
assert_raises(ValueError, linalg.solve, a[0:0], b[0:0])
assert_raises(ValueError, linalg.solve, a[:, 0:0, 0:0], b)
def test_0_size_k(self):
# test zero multiple equation (K=0) case.
class ArraySubclass(np.ndarray):
pass
a = np.arange(4).reshape(1, 2, 2)
b = np.arange(6).reshape(3, 2, 1).view(ArraySubclass)
expected = linalg.solve(a, b)[:, :, 0:0]
result = linalg.solve(a, b[:, :, 0:0])
assert_array_equal(result, expected)
assert_(isinstance(result, ArraySubclass))
# test both zero.
expected = linalg.solve(a, b)[:, 0:0, 0:0]
result = linalg.solve(a[:, 0:0, 0:0], b[:, 0:0, 0:0])
assert_array_equal(result, expected)
assert_(isinstance(result, ArraySubclass))
class InvCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
def do(self, a, b, tags):
a_inv = linalg.inv(a)
assert_almost_equal(dot_generalized(a, a_inv),
identity_like_generalized(a))
assert_(consistent_subclass(a_inv, a))
class TestInv(InvCases):
@pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
def test_types(self, dtype):
x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype)
assert_equal(linalg.inv(x).dtype, dtype)
def test_0_size(self):
# Check that all kinds of 0-sized arrays work
class ArraySubclass(np.ndarray):
pass
a = np.zeros((0, 1, 1), dtype=np.int_).view(ArraySubclass)
res = linalg.inv(a)
assert_(res.dtype.type is np.float64)
assert_equal(a.shape, res.shape)
assert_(isinstance(res, ArraySubclass))
a = np.zeros((0, 0), dtype=np.complex64).view(ArraySubclass)
res = linalg.inv(a)
assert_(res.dtype.type is np.complex64)
assert_equal(a.shape, res.shape)
assert_(isinstance(res, ArraySubclass))
class EigvalsCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
def do(self, a, b, tags):
ev = | linalg.eigvals(a) | numpy.linalg.eigvals |
import os
import copy
import sys
import numpy as np
import math
import torchvision.transforms as transforms
from torchvision.utils import save_image
from torch.utils.data import DataLoader
from torchvision import datasets
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch
def rescale(x):
x = np.asarray(x)
x = x.reshape(81, 1, 32, 32)
#x = x.reshape(16, 1, 32, 32)
return x
def convert(n, sudokus, digit_map, name, rate):
ret = []
ret_labels = []
n_iter = n // len(sudokus) + 1
offset = 1
if "digit" in name:
offset = 0
for i in range(10):
interval = int(len(digit_map[i]) // 4)
np.random.seed(123)
idx = np.arange(len(digit_map[i]))
np.random.shuffle(idx)
digit_map[i] = np.array(digit_map[i])
digit_map[i] = digit_map[i][idx]
digit_map[i] = digit_map[i][interval * rate:min(interval * (rate + 1), len(digit_map[i]))]
for i in range(n_iter):
for sudoku in sudokus:
flatten = [number - offset for sublist in sudoku for number in sublist]
ret_labels.append(flatten)
emnist_sudoku = []
for number in flatten:
rnd = np.random.randint(len(digit_map[number]))
emnist_sudoku.append(digit_map[number][rnd])
ret.append(rescale(emnist_sudoku))
return ret, ret_labels
seed = int(sys.argv[2])
np.random.seed(seed)
n = int(sys.argv[1])
img_sz = 32
#dataloader = torch.utils.data.DataLoader(
# datasets.EMNIST(
# "./emnist",
# split="byclass",
# train=True,
# download=True,
# transform=transforms.Compose(
# [transforms.Resize(img_sz), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]
# ),
# ),
# batch_size=1,
# shuffle=True,
#collate_fn=my_collate,
#)
sudokus = np.load("minimum.npy")[:, 1, :, :]
#sudokus = np.load("all4sudoku.npy")
label2digits = {}
label2upper = {}
#label2lower = {}
'''
tot = 0
for img, label in dataloader:
tot += 1
img = img.transpose(2, 3)
label = label[0].item()
img = img[0].data.numpy()
if label >= 10:
if label < 10 + 26:
label = label - 10
if label in label2upper:
label2upper[label].append(img)
else:
label2upper[label] = [img]
else:
label = label - 36
if label in label2lower:
label2lower[label].append(img)
else:
label2lower[label] = [img]
else:
if label in label2digits:
label2digits[label].append(img)
else:
label2digits[label] = [img]
'''
#label2digits = np.load("/atlaslocaldisk/shared/9by9_dichen/selected_digits.npy").item()
#label2upper = np.load("/atlaslocaldisk/shared/9by9_dichen/selected_uppers.npy").item()
label2digits = np.load("selected_digits_offset2.npy", allow_pickle=True).item()
label2upper = np.load("selected_uppers_offset2.npy", allow_pickle=True).item()
aaa = [label2digits, label2upper]
names = ["digit", "upper"]
rate_suffix = [(0, "train"), (1, "valid"), (2, "test")]
for item, name in zip(aaa, names):
ori_digit_map = copy.deepcopy(item)
for rate, suffix in rate_suffix:
rtn, rtn_labels = convert(n, sudokus, item, name, rate)
rtn, rtn_labels = rtn[:n], rtn_labels[:n]
rtn, rtn_labels = np.array(rtn), np.array(rtn_labels)
print (rtn.shape)
print (rtn_labels.shape)
s_rtn = []
s_rtn_labels = []
idx = np.arange(len(rtn))
np.random.shuffle(idx)
for i in idx:
s_rtn.append(rtn[i])
s_rtn_labels.append(rtn_labels[i])
np.save("9by9_%s_%s.npy" % (name, suffix), s_rtn)
| np.save("9by9_%s_labels_%s.npy" % (name, suffix), s_rtn_labels) | numpy.save |
import numpy as np
import cv2
#import matplotlib.pyplot as plt
import moviepy.editor as mvEdit
#import matplotlib.image as mpimg
import os, pickle, sys
# pdb is used for debugging purposes; uncomment when needed
#import pdb
# Define a Line class to store the characteristics of each line detection
class Line():
def __init__(self):
# was the line detected in the last iteration?
self.detected = False
self.alreadyRan = False
#polynomial coefficients averaged over the last n iterations
self.best_fit = None
#polynomial coefficients for the most recent fit
self.current_fit = None
# Mean-squared error in coefficients between last and best fits
self.coeff_msErr = float(0)
def bestFit_calc(self):
if not self.best_fit:
avg = self.current_fit
else:
n = len(self.best_fit)
avg = [0, 0, 0]
for i in range(len(self.current_fit)):
avg[i] = (self.best_fit[-1][i] * n + self.current_fit[i])\
/ (n + 1)
return avg
def msError_calc(self):
error = np.array(self.current_fit) - np.array(self.best_fit[-1])
# Return the mean-squared error
return error.dot(error.T)
def grad_clr_thresh(img, s_thresh=(170, 255), sx_thresh=(20, 100)):
img = np.copy(img)
# Convert to HLS color space and separate the V channel
hls = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)
l_channel = hls[:, :, 1]
s_channel = hls[:, :, 2]
# Sobel x
sobelx = cv2.Sobel(l_channel, cv2.CV_64F, 1, 0) # Take the derivative in x
abs_sobelx = np.absolute(sobelx) # Absolute x derivative to accentuate lines away from horizontal
scaled_sobel = np.uint8(255*abs_sobelx/np.max(abs_sobelx))
# Threshold x gradient
sxbinary = np.zeros_like(scaled_sobel)
sxbinary[(scaled_sobel >= sx_thresh[0]) &\
(scaled_sobel <= sx_thresh[1])] = 1
# Threshold color channel
s_binary = np.zeros_like(s_channel)
s_binary[(s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 1
# Stack each channel
color_binary = np.dstack((np.zeros_like(sxbinary),\
sxbinary, s_binary)) * 255
# Combine the two binary thresholds
combined_binary = | np.zeros_like(sxbinary) | numpy.zeros_like |
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# import palettable # tcrdist not found
from sklearn.decomposition import PCA, KernelPCA
from sklearn.manifold import Isomap, LocallyLinearEmbedding, TSNE, MDS
"""Embedding of pairwise-distance matrices."""
__all__ = [ 'embedDistanceMatrix',
'plotEmbedding',
'clusteredScatter']
def embedDistanceMatrix(dmatDf, method='kpca', n_components=2, **kwargs):
"""Two-dimensional embedding of sequence distances in dmatDf,
returning Nx2 x,y-coords: tsne, isomap, pca, mds, kpca, sklearn-tsne"""
if isinstance(dmatDf, pd.DataFrame):
dmat = dmatDf.values
else:
dmat = dmatDf
if method == 'isomap':
isoObj = Isomap(n_neighbors=10, n_components=n_components)
xy = isoObj.fit_transform(dmat)
elif method == 'mds':
mds = MDS(n_components=n_components,
max_iter=3000,
eps=1e-9,
random_state=15,
dissimilarity="precomputed",
n_jobs=1)
xy = mds.fit(dmat).embedding_
rot = PCA(n_components=n_components)
xy = rot.fit_transform(xy)
elif method == 'pca':
pcaObj = PCA(n_components=None)
xy = pcaObj.fit_transform(dmat)[:, :n_components]
elif method == 'kpca':
pcaObj = KernelPCA(n_components=dmat.shape[0], kernel='precomputed', eigen_solver='dense')
try:
gram = dist2kernel(dmat)
except:
print('Could not convert dmat to kernel for KernelPCA; using 1 - dmat/dmat.max() instead')
gram = 1 - dmat / dmat.max()
xy = pcaObj.fit_transform(gram)[:, :n_components]
elif method == 'lle':
lle = LocallyLinearEmbedding(n_neighbors=30, n_components=n_components, method='standard')
xy = lle.fit_transform(dist)
elif method == 'sklearn-tsne':
tsneObj = TSNE(n_components=n_components, metric='precomputed', random_state=0, perplexity=kwargs['perplexity'])
xy = tsneObj.fit_transform(dmat)
else:
print(('Method unknown: %s' % method))
return
assert xy.shape[0] == dmatDf.shape[0]
xyDf = pd.DataFrame(xy[:, :n_components], index=dmatDf.index, columns=np.arange(n_components))
if method == 'kpca':
"""Not sure how negative eigenvalues should be handled here, but they are usually
small so it shouldn't make a big difference"""
xyDf.explained_variance_ = pcaObj.lambdas_[:n_components]/pcaObj.lambdas_[pcaObj.lambdas_>0].sum()
return xyDf
def plotEmbedding(dmatDf,
xyDf=None,
labels=None,
method='kpca',
plotLabels=False,
plotDims=[0, 1],
weights=None,
txtSize='large',
alpha=0.8,
sz=50,
mxSz=500,
markers=None,
plotLegend=True,
colors=None,
markerLabels=None,
continuousLabel=False):
"""Two-dimensional plot of embedded distance matrix, colored by labels"""
if labels is None:
labels = np.zeros(dmatDf.shape[0])
assert dmatDf.shape[0] == dmatDf.shape[1]
assert labels.shape[0] == dmatDf.shape[0]
uLabels = freqSort(labels)
if xyDf is None:
xyDf = embedDistanceMatrix(dmatDf, method=method, n_components=np.max(plotDims) + 1)
clusteredScatter(xyDf,
labels=labels,
plotDims=plotDims,
weights=weights,
alpha=alpha,
sz=sz,
mxSz=mxSz,
markerLabels=markerLabels,
markers=markers,
continuousLabel=continuousLabel,
colors=colors)
if plotLabels:
annotationParams = dict(xytext=(0, 5), textcoords='offset points', size=txtSize)
for coli, col in enumerate(dmatDf.columns):
if plotLabels:
axh.annotate(col, xy=(xyDf.loc[col, plotDims[0]], xyDf.loc[col, plotDims[1]]), **annotationParams)
if len(uLabels) > 1 and plotLegend:
if labels is None and markerLabels is None:
pass
else:
if labels is None:
legTit = markerLabels.name
elif markerLabels is None:
legTit = abels.name
else:
legTit = '%s | %s' % (labels.name, markerLabels.name)
plt.legend(loc=0, title=legTit)
if hasattr(xyDf, 'explained_variance_'):
plt.xlabel('KPCA %1.0f (%1.0f%% variance explained)' % (plotDims[0]+1, 100*xyDf.explained_variance_[plotDims[0]]))
plt.ylabel('KPCA %1.0f (%1.0f%% variance explained)' % (plotDims[1]+1, 100*xyDf.explained_variance_[plotDims[1]]))
else:
plt.xlabel('KPCA %1.0f' % (plotDims[0]+1))
plt.ylabel('KPCA %1.0f' % (plotDims[1]+1))
plt.show()
return xyDf
def clusteredScatter(xyDf,
labels=None,
plotDims=[0, 1],
weights=None,
alpha=0.8,
sz=50,
mxSz=500,
markerLabels=None,
markers=None,
colors=None,
continuousLabel=False):
"""Produce a scatter plot with axes, shaded by values in labels and with specified markers
Parameters
----------
xyDf : pd.DataFrame
One column for each plot dimension specified
labels : pd.Series
Holds categorical or continuous metadata used for coloring
plotDims : list len 2
Specifies the columns in xyDf for plotting on X and Y axes
weights : pd.Series
Relative weights that are mapped for sizing each symbol
alpha : float
Transparency of each point
sz : float
Size of each symbol or minimum size of a symbol if there are weights
mxSz : float
Maximum size of a symbol if there are weights
markerLabels : pd.Series
Holds categorical labels used for plotting different symbols
markers : list
List of marker symbols to use. Defaults to: "ov8sp*hDPX"
colors : list
List of colors to use for categorical labels or a colormap
for a continuousLabel. Defaults to colors from Set1 or the YlOrRd colormap
continuousLabel : bool
Indicates whether labels are categorical or continuous"""
if weights is None:
sVec = sz * pd.Series(np.ones(xyDf.shape[0]), index=xyDf.index)
else:
sVec = weights * mxSz + sz
if labels is None:
labels = pd.Series(np.ones(xyDf.shape[0]), index=xyDf.index)
useColors = False
else:
useColors = True
if continuousLabel:
if not colors is None:
cmap = colors
else:
cmap = palettable.colorbrewer.sequential.YlOrRd_9.mpl_colormap
else:
cmap = None
uLabels = freqSort(labels)
if colors is None:
nColors = min(max(len(uLabels), 3), 9)
colors = palettable.colorbrewer.get_map('Set1', 'Qualitative', nColors).mpl_colors
elif isinstance(colors, pd.Series):
colors = colors[uLabels].values
if markerLabels is None:
markerLabels = pd.Series(np.ones(xyDf.shape[0]), index=xyDf.index)
useMarkers = False
else:
useMarkers = True
uMLabels = freqSort(markerLabels)
if markers is None:
nMarkers = len(uMLabels)
markers = ['o', 'v', '8', 's', 'p', '*', 'h', 'D', 'P', 'X'][:nMarkers]
elif isinstance(markers, pd.Series):
markers = markers[uMLabels].values
figh = plt.gcf()
plt.clf()
axh = figh.add_axes([0.05, 0.05, 0.9, 0.9])
axh.patch.set_facecolor('white')
# axh.axis('off')
figh.patch.set_facecolor('white')
if continuousLabel:
for mi, m in enumerate(uMLabels):
ind = markerLabels == m
if useMarkers:
labS = '%s (N=%d)' % (m, ind.sum())
else:
labS = None
plt.scatter(xyDf.loc[ind, plotDims[0]],
xyDf.loc[ind, plotDims[1]],
marker=markers[mi],
s=sVec.loc[ind],
alpha=alpha,
c=labels.loc[ind],
label=labS,
cmap=cmap)
else:
for vi, v in enumerate(uLabels):
for mi, m in enumerate(uMLabels):
ind = (labels == v) & (markerLabels == m)
if useMarkers and useColors:
labS = '%s|%s (N=%d)' % (v, m, ind.sum())
elif useColors:
labS = '%s (N=%d)' % (v, ind.sum())
elif useMarkers:
labS = '%s (N=%d)' % (m, ind.sum())
else:
labS = None
plt.scatter(xyDf.loc[ind, plotDims[0]],
xyDf.loc[ind, plotDims[1]],
marker=markers[mi],
s=sVec.loc[ind],
alpha=alpha,
c=[colors[vi % len(colors)], ] * ind.sum(),
label=labS,
cmap=cmap)
axh.set_xticks(())
axh.set_yticks(())
plt.show()
def dist2kernel(dmat):
"""Convert a distance matrix into a similarity kernel
for KernelPCA or kernel regression methods.
Implementation of D2K in MiRKAT, Zhao et al., 2015
Parameters
----------
dmat : ndarray shape (n,n)
Pairwise-distance matrix.
Returns
-------
kernel : ndarray shape (n,n)"""
n = dmat.shape[0]
I = np.identity(n)
"""m = I - dot(1,1')/n"""
m = I - np.ones((n, n))/float(n)
kern = -0.5 * | np.linalg.multi_dot((m, dmat**2, m)) | numpy.linalg.multi_dot |
"""Module for remapping complex data for display."""
from inspect import getmembers, isfunction
import sys
import numpy as np
from scipy.stats import scoreatpercentile as prctile
__classification__ = "UNCLASSIFIED"
__author__ = "<NAME>"
def get_remap_list():
"""
Create list of remap functions accessible from this module.
Returns
-------
List[Tuple[str, callable], ...]
List of tuples of the form `(<function name>, <function>)`.
"""
# We specifically list these as the only funtions in is this module that are
# not remaps. If we later add other utility functions to this module, we
# will have to manually add them to this list as well. However, we don't
# have to do anything if we are just adding more remap functions.
names_nonremap_funs = ['get_remap_list', 'amplitude_to_density', '_clip_cast']
# Get all functions from this module
all_funs = getmembers(sys.modules[__name__], isfunction)
# all_funs is list of (function name, function object) tuples. fun[0] is name.
just_remap_funs = [fun for fun in all_funs if fun[0] not in names_nonremap_funs]
return just_remap_funs
def amplitude_to_density(a, dmin=30, mmult=40, data_mean=None):
"""
Convert to density data for remap.
Parameters
----------
a : numpy.ndarray
dmin : float|int
mmult : float|int
data_mean : None|float|int
Returns
-------
numpy.ndarray
"""
EPS = 1e-5
if (a==0).all():
return np.zeros(a.shape)
else:
a = abs(a)
if not data_mean:
data_mean = np.mean(a[np.isfinite(a)])
cl = 0.8 * data_mean
ch = mmult * cl
m = (255 - dmin)/np.log10(ch/cl)
b = dmin - (m * np.log10(cl))
return (m * np.log10(np.maximum(a, EPS))) + b
# Does Python not have a builtin way to do this fundamental operation???
def _clip_cast(x, dtype='uint8'):
"""
Cast by clipping values outside of valid range, rather than wrapping.
Parameters
----------
x : numpy.ndarray
dtype : str|numpy.dtype
Returns
-------
numpy.ndarray
"""
np_type = np.dtype(dtype)
return np.clip(x, np.iinfo(np_type).min, np.iinfo(np_type).max).astype(dtype)
def density(x):
"""
Standard set of parameters for density remap.
Parameters
----------
x : numpy.ndarray
Returns
-------
numpy.ndarray
"""
return _clip_cast(amplitude_to_density(x))
def brighter(x):
"""
Brighter set of parameters for density remap.
Parameters
----------
x : numpy.ndarray
Returns
-------
numpy.ndarray
"""
return _clip_cast(amplitude_to_density(x, 60, 40))
def darker(x):
"""
Darker set of parameters for density remap.
Parameters
----------
x : numpy.ndarray
Returns
-------
numpy.ndarray
"""
return _clip_cast(amplitude_to_density(x, 0, 40))
def highcontrast(x):
"""
Increased contrast set of parameters for density remap.
Parameters
----------
x : numpy.ndarray
Returns
-------
numpy.ndarray
"""
return _clip_cast(amplitude_to_density(x, 30, 4))
def linear(x):
"""
Linear remap - just the magnitude.
Parameters
----------
x : numpy.ndarray
Returns
-------
numpy.ndarray
"""
if np.iscomplexobj(x):
return np.abs(x)
else:
return x
def log(x):
"""
Logarithmic remap.
Parameters
----------
x : numpy.ndarray
Returns
-------
numpy.ndarray
"""
out = np.log(np.abs(x))
out[np.logical_not( | np.isfinite(out) | numpy.isfinite |
# -*- coding: utf-8 -*-
"""
Defines unit tests for :mod:`colour.models.rgb.transfer_functions.itur_bt_2100`
module.
"""
from __future__ import division, unicode_literals
import numpy as np
import unittest
from colour.models.rgb.transfer_functions import (
oetf_PQ_BT2100, oetf_inverse_PQ_BT2100, eotf_PQ_BT2100,
eotf_inverse_PQ_BT2100, ootf_PQ_BT2100, ootf_inverse_PQ_BT2100,
oetf_HLG_BT2100, oetf_inverse_HLG_BT2100)
from colour.models.rgb.transfer_functions.itur_bt_2100 import (
eotf_HLG_BT2100_1, eotf_HLG_BT2100_2, eotf_inverse_HLG_BT2100_1,
eotf_inverse_HLG_BT2100_2, ootf_HLG_BT2100_1, ootf_HLG_BT2100_2,
ootf_inverse_HLG_BT2100_1, ootf_inverse_HLG_BT2100_2)
from colour.models.rgb.transfer_functions.itur_bt_2100 import (
gamma_function_HLG_BT2100)
from colour.utilities import domain_range_scale, ignore_numpy_errors
__author__ = 'Colour Developers'
__copyright__ = 'Copyright (C) 2013-2019 - Colour Developers'
__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'
__maintainer__ = 'Colour Developers'
__email__ = '<EMAIL>'
__status__ = 'Production'
__all__ = [
'TestOetf_PQ_BT2100', 'TestOetf_inverse_PQ_BT2100', 'TestEotf_PQ_BT2100',
'TestEotf_inverse_PQ_BT2100', 'TestOotf_PQ_BT2100',
'TestOotf_inverse_PQ_BT2100', 'TestGamma_function_HLG_BT2100',
'TestOetf_HLG_BT2100', 'TestOetf_inverse_HLG_BT2100',
'TestEotf_HLG_BT2100_1', 'TestEotf_HLG_BT2100_2',
'TestEotf_inverse_HLG_BT2100_1', 'TestEotf_inverse_HLG_BT2100_2',
'TestOotf_HLG_BT2100_1', 'TestOotf_HLG_BT2100_2',
'TestOotf_inverse_HLG_BT2100_1', 'TestOotf_inverse_HLG_BT2100_2'
]
class TestOetf_PQ_BT2100(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_PQ_BT2100` definition unit tests methods.
"""
def test_oetf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_PQ_BT2100` definition.
"""
self.assertAlmostEqual(
oetf_PQ_BT2100(0.0), 0.000000730955903, places=7)
self.assertAlmostEqual(
oetf_PQ_BT2100(0.1), 0.724769816665726, places=7)
self.assertAlmostEqual(
oetf_PQ_BT2100(1.0), 0.999999934308041, places=7)
def test_n_dimensional_oetf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_PQ_BT2100` definition n-dimensional arrays support.
"""
E = 0.1
E_p = oetf_PQ_BT2100(E)
E = np.tile(E, 6)
E_p = np.tile(E_p, 6)
np.testing.assert_almost_equal(oetf_PQ_BT2100(E), E_p, decimal=7)
E = np.reshape(E, (2, 3))
E_p = np.reshape(E_p, (2, 3))
np.testing.assert_almost_equal(oetf_PQ_BT2100(E), E_p, decimal=7)
E = np.reshape(E, (2, 3, 1))
E_p = np.reshape(E_p, (2, 3, 1))
np.testing.assert_almost_equal(oetf_PQ_BT2100(E), E_p, decimal=7)
def test_domain_range_scale_oetf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_PQ_BT2100` definition domain and range scale support.
"""
E = 0.1
E_p = oetf_PQ_BT2100(E)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
oetf_PQ_BT2100(E * factor), E_p * factor, decimal=7)
@ignore_numpy_errors
def test_nan_oetf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_PQ_BT2100` definition nan support.
"""
oetf_PQ_BT2100(np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestOetf_inverse_PQ_BT2100(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_inverse_PQ_BT2100` definition unit tests methods.
"""
def test_oetf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_inverse_PQ_BT2100` definition.
"""
self.assertAlmostEqual(
oetf_inverse_PQ_BT2100(0.000000730955903), 0.0, places=7)
self.assertAlmostEqual(
oetf_inverse_PQ_BT2100(0.724769816665726), 0.1, places=7)
self.assertAlmostEqual(
oetf_inverse_PQ_BT2100(0.999999934308041), 1.0, places=7)
def test_n_dimensional_oetf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_inverse_PQ_BT2100` definition n-dimensional arrays support.
"""
E_p = 0.724769816665726
E = oetf_inverse_PQ_BT2100(E_p)
E_p = np.tile(E_p, 6)
E = np.tile(E, 6)
np.testing.assert_almost_equal(
oetf_inverse_PQ_BT2100(E_p), E, decimal=7)
E_p = np.reshape(E_p, (2, 3))
E = np.reshape(E, (2, 3))
np.testing.assert_almost_equal(
oetf_inverse_PQ_BT2100(E_p), E, decimal=7)
E_p = np.reshape(E_p, (2, 3, 1))
E = np.reshape(E, (2, 3, 1))
np.testing.assert_almost_equal(
oetf_inverse_PQ_BT2100(E_p), E, decimal=7)
def test_domain_range_scale_oetf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_inverse_PQ_BT2100` definition domain and range scale support.
"""
E_p = 0.724769816665726
E = oetf_inverse_PQ_BT2100(E_p)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
oetf_inverse_PQ_BT2100(E_p * factor),
E * factor,
decimal=7)
@ignore_numpy_errors
def test_nan_oetf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_inverse_PQ_BT2100` definition nan support.
"""
oetf_inverse_PQ_BT2100(
np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestEotf_PQ_BT2100(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_PQ_BT2100` definition unit tests methods.
"""
def test_eotf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_PQ_BT2100` definition.
"""
self.assertAlmostEqual(eotf_PQ_BT2100(0.0), 0.0, places=7)
self.assertAlmostEqual(
eotf_PQ_BT2100(0.724769816665726), 779.98836083408537, places=7)
self.assertAlmostEqual(eotf_PQ_BT2100(1.0), 10000.0, places=7)
def test_n_dimensional_eotf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_PQ_BT2100` definition n-dimensional arrays support.
"""
E_p = 0.724769816665726
F_D = eotf_PQ_BT2100(E_p)
E_p = np.tile(E_p, 6)
F_D = np.tile(F_D, 6)
np.testing.assert_almost_equal(eotf_PQ_BT2100(E_p), F_D, decimal=7)
E_p = np.reshape(E_p, (2, 3))
F_D = np.reshape(F_D, (2, 3))
np.testing.assert_almost_equal(eotf_PQ_BT2100(E_p), F_D, decimal=7)
E_p = np.reshape(E_p, (2, 3, 1))
F_D = np.reshape(F_D, (2, 3, 1))
np.testing.assert_almost_equal(eotf_PQ_BT2100(E_p), F_D, decimal=7)
def test_domain_range_scale_eotf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_PQ_BT2100` definition domain and range scale support.
"""
E_p = 0.724769816665726
F_D = eotf_PQ_BT2100(E_p)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
eotf_PQ_BT2100(E_p * factor), F_D * factor, decimal=7)
@ignore_numpy_errors
def test_nan_eotf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_PQ_BT2100` definition nan support.
"""
eotf_PQ_BT2100(np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestEotf_inverse_PQ_BT2100(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_PQ_BT2100` definition unit tests methods.
"""
def test_eotf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_PQ_BT2100` definition.
"""
self.assertAlmostEqual(
eotf_inverse_PQ_BT2100(0.0), 0.000000730955903, places=7)
self.assertAlmostEqual(
eotf_inverse_PQ_BT2100(779.98836083408537),
0.724769816665726,
places=7)
self.assertAlmostEqual(eotf_inverse_PQ_BT2100(10000.0), 1.0, places=7)
def test_n_dimensional_eotf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_PQ_BT2100` definition n-dimensional arrays support.
"""
F_D = 779.98836083408537
E_p = eotf_inverse_PQ_BT2100(F_D)
F_D = np.tile(F_D, 6)
E_p = np.tile(E_p, 6)
np.testing.assert_almost_equal(
eotf_inverse_PQ_BT2100(F_D), E_p, decimal=7)
F_D = np.reshape(F_D, (2, 3))
E_p = np.reshape(E_p, (2, 3))
np.testing.assert_almost_equal(
eotf_inverse_PQ_BT2100(F_D), E_p, decimal=7)
F_D = np.reshape(F_D, (2, 3, 1))
E_p = np.reshape(E_p, (2, 3, 1))
np.testing.assert_almost_equal(
eotf_inverse_PQ_BT2100(F_D), E_p, decimal=7)
def test_domain_range_scale_eotf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_PQ_BT2100` definition domain and range scale support.
"""
F_D = 779.98836083408537
E_p = eotf_inverse_PQ_BT2100(F_D)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
eotf_inverse_PQ_BT2100(F_D * factor),
E_p * factor,
decimal=7)
@ignore_numpy_errors
def test_nan_eotf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_PQ_BT2100` definition nan support.
"""
eotf_inverse_PQ_BT2100(
np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestOotf_PQ_BT2100(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_PQ_BT2100` definition unit tests methods.
"""
def test_ootf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_PQ_BT2100` definition.
"""
self.assertAlmostEqual(ootf_PQ_BT2100(0.0), 0.0, places=7)
self.assertAlmostEqual(
ootf_PQ_BT2100(0.1), 779.98836083411584, places=7)
self.assertAlmostEqual(
ootf_PQ_BT2100(1.0), 9999.993723673924300, places=7)
def test_n_dimensional_ootf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_PQ_BT2100` definition n-dimensional arrays support.
"""
E = 0.1
F_D = ootf_PQ_BT2100(E)
E = np.tile(E, 6)
F_D = np.tile(F_D, 6)
np.testing.assert_almost_equal(ootf_PQ_BT2100(E), F_D, decimal=7)
E = np.reshape(E, (2, 3))
F_D = np.reshape(F_D, (2, 3))
np.testing.assert_almost_equal(ootf_PQ_BT2100(E), F_D, decimal=7)
E = np.reshape(E, (2, 3, 1))
F_D = np.reshape(F_D, (2, 3, 1))
np.testing.assert_almost_equal(ootf_PQ_BT2100(E), F_D, decimal=7)
def test_domain_range_scale_ootf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_PQ_BT2100` definition domain and range scale support.
"""
E = 0.1
F_D = ootf_PQ_BT2100(E)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
ootf_PQ_BT2100(E * factor), F_D * factor, decimal=7)
@ignore_numpy_errors
def test_nan_ootf_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_PQ_BT2100` definition nan support.
"""
ootf_PQ_BT2100(np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestOotf_inverse_PQ_BT2100(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_inverse_PQ_BT2100` definition unit tests methods.
"""
def test_ootf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_inverse_PQ_BT2100` definition.
"""
self.assertAlmostEqual(ootf_inverse_PQ_BT2100(0.0), 0.0, places=7)
self.assertAlmostEqual(
ootf_inverse_PQ_BT2100(779.98836083411584), 0.1, places=7)
self.assertAlmostEqual(
ootf_inverse_PQ_BT2100(9999.993723673924300), 1.0, places=7)
def test_n_dimensional_ootf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_inverse_PQ_BT2100` definition n-dimensional arrays support.
"""
F_D = 779.98836083411584
E = ootf_inverse_PQ_BT2100(F_D)
F_D = np.tile(F_D, 6)
E = np.tile(E, 6)
np.testing.assert_almost_equal(
ootf_inverse_PQ_BT2100(F_D), E, decimal=7)
F_D = np.reshape(F_D, (2, 3))
E = np.reshape(E, (2, 3))
np.testing.assert_almost_equal(
ootf_inverse_PQ_BT2100(F_D), E, decimal=7)
F_D = np.reshape(F_D, (2, 3, 1))
E = np.reshape(E, (2, 3, 1))
np.testing.assert_almost_equal(
ootf_inverse_PQ_BT2100(F_D), E, decimal=7)
def test_domain_range_scale_ootf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_inverse_PQ_BT2100` definition domain and range scale support.
"""
F_D = 779.98836083411584
E = ootf_inverse_PQ_BT2100(F_D)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
ootf_inverse_PQ_BT2100(F_D * factor),
E * factor,
decimal=7)
@ignore_numpy_errors
def test_nan_ootf_inverse_PQ_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_inverse_PQ_BT2100` definition nan support.
"""
ootf_inverse_PQ_BT2100(
np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestGamma_function_HLG_BT2100(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
gamma_function_HLG_BT2100` definition unit tests methods.
"""
def test_gamma_function_HLG_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
gamma_function_HLG_BT2100` definition.
"""
self.assertAlmostEqual(
gamma_function_HLG_BT2100(1000.0), 1.2, places=7)
self.assertAlmostEqual(
gamma_function_HLG_BT2100(2000.0), 1.326432598178872, places=7)
self.assertAlmostEqual(
gamma_function_HLG_BT2100(4000.0), 1.452865196357744, places=7)
self.assertAlmostEqual(
gamma_function_HLG_BT2100(10000.0), 1.619999999999999, places=7)
class TestOetf_HLG_BT2100(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_HLG_BT2100` definition unit tests methods.
"""
def test_oetf_HLG_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_HLG_BT2100` definition.
"""
self.assertAlmostEqual(oetf_HLG_BT2100(0.0), 0.0, places=7)
self.assertAlmostEqual(
oetf_HLG_BT2100(0.18 / 12), 0.212132034355964, places=7)
self.assertAlmostEqual(
oetf_HLG_BT2100(1.0), 0.999999995536569, places=7)
def test_n_dimensional_oetf_HLG_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_HLG_BT2100` definition n-dimensional arrays support.
"""
E = 0.18 / 12
E_p = oetf_HLG_BT2100(E)
E = np.tile(E, 6)
E_p = np.tile(E_p, 6)
np.testing.assert_almost_equal(oetf_HLG_BT2100(E), E_p, decimal=7)
E = np.reshape(E, (2, 3))
E_p = np.reshape(E_p, (2, 3))
np.testing.assert_almost_equal(oetf_HLG_BT2100(E), E_p, decimal=7)
E = np.reshape(E, (2, 3, 1))
E_p = np.reshape(E_p, (2, 3, 1))
np.testing.assert_almost_equal(oetf_HLG_BT2100(E), E_p, decimal=7)
def test_domain_range_scale_oetf_HLG_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_HLG_BT2100` definition domain and range scale support.
"""
E = 0.18 / 12
E_p = oetf_HLG_BT2100(E)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
oetf_HLG_BT2100(E * factor), E_p * factor, decimal=7)
@ignore_numpy_errors
def test_nan_oetf_HLG_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_HLG_BT2100` definition nan support.
"""
oetf_HLG_BT2100(np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestOetf_inverse_HLG_BT2100(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_inverse_HLG_BT2100` definition unit tests methods.
"""
def test_oetf_inverse_HLG_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_inverse_HLG_BT2100` definition.
"""
self.assertAlmostEqual(oetf_inverse_HLG_BT2100(0.0), 0.0, places=7)
self.assertAlmostEqual(
oetf_inverse_HLG_BT2100(0.212132034355964), 0.18 / 12, places=7)
self.assertAlmostEqual(
oetf_inverse_HLG_BT2100(0.999999995536569), 1.0, places=7)
def test_n_dimensional_oetf_inverse_HLG_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_inverse_HLG_BT2100` definition n-dimensional arrays support.
"""
E_p = 0.212132034355964
E = oetf_inverse_HLG_BT2100(E_p)
E_p = np.tile(E_p, 6)
E = np.tile(E, 6)
np.testing.assert_almost_equal(
oetf_inverse_HLG_BT2100(E_p), E, decimal=7)
E_p = np.reshape(E_p, (2, 3))
E = np.reshape(E, (2, 3))
np.testing.assert_almost_equal(
oetf_inverse_HLG_BT2100(E_p), E, decimal=7)
E_p = np.reshape(E_p, (2, 3, 1))
E = np.reshape(E, (2, 3, 1))
np.testing.assert_almost_equal(
oetf_inverse_HLG_BT2100(E_p), E, decimal=7)
def test_domain_range_scale_oetf_inverse_HLG_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_inverse_HLG_BT2100` definition domain and range scale support.
"""
E_p = 0.212132034355964
E = oetf_inverse_HLG_BT2100(E_p)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
oetf_inverse_HLG_BT2100(E_p * factor),
E * factor,
decimal=7)
@ignore_numpy_errors
def test_nan_oetf_inverse_HLG_BT2100(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
oetf_inverse_HLG_BT2100` definition nan support.
"""
oetf_inverse_HLG_BT2100(
np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestEotf_HLG_BT2100_1(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_HLG_BT2100_1` definition unit tests methods.
"""
def test_eotf_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_HLG_BT2100_1` definition.
"""
self.assertAlmostEqual(eotf_HLG_BT2100_1(0.0), 0.0, places=7)
self.assertAlmostEqual(
eotf_HLG_BT2100_1(0.212132034355964), 6.476039825649814, places=7)
self.assertAlmostEqual(
eotf_HLG_BT2100_1(1.0), 1000.000032321769100, places=7)
self.assertAlmostEqual(
eotf_HLG_BT2100_1(0.212132034355964, 0.001, 10000, 1.4),
27.96039175299561,
places=7)
def test_n_dimensional_eotf_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_HLG_BT2100_1` definition n-dimensional arrays support.
"""
E_p = 0.212132034355964
F_D = eotf_HLG_BT2100_1(E_p)
E_p = np.tile(E_p, 6)
F_D = np.tile(F_D, 6)
np.testing.assert_almost_equal(eotf_HLG_BT2100_1(E_p), F_D, decimal=7)
E_p = np.reshape(E_p, (2, 3))
F_D = np.reshape(F_D, (2, 3))
np.testing.assert_almost_equal(eotf_HLG_BT2100_1(E_p), F_D, decimal=7)
E_p = np.reshape(E_p, (2, 3, 1))
F_D = np.reshape(F_D, (2, 3, 1))
np.testing.assert_almost_equal(eotf_HLG_BT2100_1(E_p), F_D, decimal=7)
E_p = np.reshape(E_p, (6, 1))
F_D = np.reshape(F_D, (6, 1))
np.testing.assert_almost_equal(eotf_HLG_BT2100_1(E_p), F_D, decimal=7)
E_p = np.array([0.25, 0.50, 0.75])
F_D = np.array([12.49759413, 49.99037650, 158.94693786])
np.testing.assert_almost_equal(eotf_HLG_BT2100_1(E_p), F_D, decimal=7)
E_p = np.tile(E_p, (6, 1))
F_D = np.tile(F_D, (6, 1))
np.testing.assert_almost_equal(eotf_HLG_BT2100_1(E_p), F_D, decimal=7)
E_p = np.reshape(E_p, (2, 3, 3))
F_D = np.reshape(F_D, (2, 3, 3))
np.testing.assert_almost_equal(eotf_HLG_BT2100_1(E_p), F_D, decimal=7)
def test_domain_range_scale_eotf_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_HLG_BT2100_1` definition domain and range scale support.
"""
E_p = 0.212132034355964
F_D = eotf_HLG_BT2100_1(E_p)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
eotf_HLG_BT2100_1(E_p * factor), F_D * factor, decimal=7)
@ignore_numpy_errors
def test_nan_eotf_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_HLG_BT2100_1` definition nan support.
"""
eotf_HLG_BT2100_1(np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestEotf_HLG_BT2100_2(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_HLG_BT2100_2` definition unit tests methods.
"""
def test_eotf_HLG_BT2100_2(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_HLG_BT2100_2` definition.
"""
self.assertAlmostEqual(eotf_HLG_BT2100_2(0.0), 0.0, places=7)
self.assertAlmostEqual(
eotf_HLG_BT2100_2(0.212132034355964), 6.476039825649814, places=7)
self.assertAlmostEqual(
eotf_HLG_BT2100_2(1.0), 1000.000032321769100, places=7)
self.assertAlmostEqual(
eotf_HLG_BT2100_2(0.212132034355964, 0.001, 10000, 1.4),
29.581261576946076,
places=7)
def test_n_dimensional_eotf_HLG_BT2100_2(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_HLG_BT2100_2` definition n-dimensional arrays support.
"""
E_p = 0.212132034355964
F_D = eotf_HLG_BT2100_2(E_p)
E_p = np.tile(E_p, 6)
F_D = np.tile(F_D, 6)
np.testing.assert_almost_equal(eotf_HLG_BT2100_2(E_p), F_D, decimal=7)
E_p = np.reshape(E_p, (2, 3))
F_D = np.reshape(F_D, (2, 3))
np.testing.assert_almost_equal(eotf_HLG_BT2100_2(E_p), F_D, decimal=7)
E_p = np.reshape(E_p, (2, 3, 1))
F_D = np.reshape(F_D, (2, 3, 1))
np.testing.assert_almost_equal(eotf_HLG_BT2100_2(E_p), F_D, decimal=7)
E_p = np.reshape(E_p, (6, 1))
F_D = np.reshape(F_D, (6, 1))
np.testing.assert_almost_equal(eotf_HLG_BT2100_2(E_p), F_D, decimal=7)
E_p = np.array([0.25, 0.50, 0.75])
F_D = np.array([12.49759413, 49.99037650, 158.94693786])
np.testing.assert_almost_equal(eotf_HLG_BT2100_2(E_p), F_D, decimal=7)
E_p = np.tile(E_p, (6, 1))
F_D = np.tile(F_D, (6, 1))
np.testing.assert_almost_equal(eotf_HLG_BT2100_2(E_p), F_D, decimal=7)
E_p = np.reshape(E_p, (2, 3, 3))
F_D = np.reshape(F_D, (2, 3, 3))
np.testing.assert_almost_equal(eotf_HLG_BT2100_2(E_p), F_D, decimal=7)
def test_domain_range_scale_eotf_HLG_BT2100_2(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_HLG_BT2100_2` definition domain and range scale support.
"""
E_p = 0.212132034355964
F_D = eotf_HLG_BT2100_2(E_p)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
eotf_HLG_BT2100_2(E_p * factor), F_D * factor, decimal=7)
@ignore_numpy_errors
def test_nan_eotf_HLG_BT2100_2(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_HLG_BT2100_2` definition nan support.
"""
eotf_HLG_BT2100_2(np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestEotf_inverse_HLG_BT2100_1(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_HLG_BT2100_1` definition unit tests methods.
"""
def test_eotf_inverse_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_HLG_BT2100_1` definition.
"""
self.assertAlmostEqual(eotf_inverse_HLG_BT2100_1(0.0), 0.0, places=7)
self.assertAlmostEqual(
eotf_inverse_HLG_BT2100_1(6.476039825649814),
0.212132034355964,
places=7)
self.assertAlmostEqual(
eotf_inverse_HLG_BT2100_1(1000.000032321769100), 1.0, places=7)
self.assertAlmostEqual(
eotf_inverse_HLG_BT2100_1(27.96039175299561, 0.001, 10000, 1.4),
0.212132034355964,
places=7)
def test_n_dimensional_eotf_inverse_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_HLG_BT2100_1` definition n-dimensional arrays support.
"""
F_D = 6.476039825649814
E_p = eotf_inverse_HLG_BT2100_1(F_D)
F_D = np.tile(F_D, 6)
E_p = np.tile(E_p, 6)
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_1(F_D), E_p, decimal=7)
F_D = np.reshape(F_D, (2, 3))
E_p = np.reshape(E_p, (2, 3))
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_1(F_D), E_p, decimal=7)
F_D = np.reshape(F_D, (2, 3, 1))
E_p = np.reshape(E_p, (2, 3, 1))
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_1(F_D), E_p, decimal=7)
F_D = np.reshape(F_D, (6, 1))
E_p = np.reshape(E_p, (6, 1))
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_1(F_D), E_p, decimal=7)
F_D = np.array([12.49759413, 49.99037650, 158.94693786])
E_p = np.array([0.25, 0.50, 0.75])
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_1(F_D), E_p, decimal=7)
F_D = np.tile(F_D, (6, 1))
E_p = np.tile(E_p, (6, 1))
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_1(F_D), E_p, decimal=7)
F_D = np.reshape(F_D, (2, 3, 3))
E_p = np.reshape(E_p, (2, 3, 3))
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_1(F_D), E_p, decimal=7)
def test_domain_range_scale_eotf_inverse_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_HLG_BT2100_1` definition domain and range scale support.
"""
F_D = 6.476039825649814
E_p = eotf_inverse_HLG_BT2100_1(F_D)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_1(F_D * factor),
E_p * factor,
decimal=7)
@ignore_numpy_errors
def test_nan_eotf_inverse_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_HLG_BT2100_1` definition nan support.
"""
eotf_inverse_HLG_BT2100_1(
np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestEotf_inverse_HLG_BT2100_2(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_HLG_BT2100_2` definition unit tests methods.
"""
def test_eotf_inverse_HLG_BT2100_2(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_HLG_BT2100_2` definition.
"""
self.assertAlmostEqual(eotf_inverse_HLG_BT2100_2(0.0), 0.0, places=7)
self.assertAlmostEqual(
eotf_inverse_HLG_BT2100_2(6.476039825649814),
0.212132034355964,
places=7)
self.assertAlmostEqual(
eotf_inverse_HLG_BT2100_2(1000.000032321769100), 1.0, places=7)
self.assertAlmostEqual(
eotf_inverse_HLG_BT2100_2(29.581261576946076, 0.001, 10000, 1.4),
0.212132034355964,
places=7)
def test_n_dimensional_eotf_inverse_HLG_BT2100_2(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_HLG_BT2100_2` definition n-dimensional arrays support.
"""
F_D = 6.476039825649814
E_p = eotf_inverse_HLG_BT2100_2(F_D)
F_D = np.tile(F_D, 6)
E_p = np.tile(E_p, 6)
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_2(F_D), E_p, decimal=7)
F_D = np.reshape(F_D, (2, 3))
E_p = np.reshape(E_p, (2, 3))
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_2(F_D), E_p, decimal=7)
F_D = np.reshape(F_D, (2, 3, 1))
E_p = np.reshape(E_p, (2, 3, 1))
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_2(F_D), E_p, decimal=7)
F_D = np.reshape(F_D, (6, 1))
E_p = np.reshape(E_p, (6, 1))
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_2(F_D), E_p, decimal=7)
F_D = np.array([12.49759413, 49.99037650, 158.94693786])
E_p = np.array([0.25, 0.50, 0.75])
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_2(F_D), E_p, decimal=7)
F_D = np.tile(F_D, (6, 1))
E_p = np.tile(E_p, (6, 1))
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_2(F_D), E_p, decimal=7)
F_D = np.reshape(F_D, (2, 3, 3))
E_p = np.reshape(E_p, (2, 3, 3))
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_2(F_D), E_p, decimal=7)
def test_domain_range_scale_eotf_inverse_HLG_BT2100_2(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_HLG_BT2100_2` definition domain and range scale support.
"""
F_D = 6.476039825649814
E_p = eotf_inverse_HLG_BT2100_2(F_D)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
eotf_inverse_HLG_BT2100_2(F_D * factor),
E_p * factor,
decimal=7)
@ignore_numpy_errors
def test_nan_eotf_inverse_HLG_BT2100_2(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
eotf_inverse_HLG_BT2100_2` definition nan support.
"""
eotf_inverse_HLG_BT2100_2(
np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestOotf_HLG_BT2100_1(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_HLG_BT2100_1` definition unit tests methods.
"""
def test_ootf_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_HLG_BT2100_1` definition.
"""
self.assertAlmostEqual(ootf_HLG_BT2100_1(0.0), 0.0, places=7)
self.assertAlmostEqual(
ootf_HLG_BT2100_1(0.1), 63.095734448019336, places=7)
self.assertAlmostEqual(ootf_HLG_BT2100_1(1.0), 1000.0, places=7)
self.assertAlmostEqual(
ootf_HLG_BT2100_1(0.1, 0.001, 10000, 1.4),
398.108130742780300,
places=7)
a = np.array(
[[45.884942278760597, 0.000000000000000, -45.884942278760597], [
-63.095734448019336, -63.095734448019336, -63.095734448019336
], [63.095734448019336, 63.095734448019336, 63.095734448019336],
[51.320396090100672, -51.320396090100672, 51.320396090100672]], )
np.testing.assert_almost_equal(
ootf_HLG_BT2100_1(
np.array([[0.1, 0.0, -0.1], [-0.1, -0.1, -0.1],
[0.1, 0.1, 0.1], [0.1, -0.1, 0.1]])),
a,
decimal=7)
def test_n_dimensional_ootf_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_HLG_BT2100_1` definition n-dimensional arrays support.
"""
E = 0.1
F_D = ootf_HLG_BT2100_1(E)
E = np.tile(E, 6)
F_D = np.tile(F_D, 6)
np.testing.assert_almost_equal(ootf_HLG_BT2100_1(E), F_D, decimal=7)
E = np.reshape(E, (2, 3))
F_D = np.reshape(F_D, (2, 3))
np.testing.assert_almost_equal(ootf_HLG_BT2100_1(E), F_D, decimal=7)
E = np.reshape(E, (2, 3, 1))
F_D = np.reshape(F_D, (2, 3, 1))
np.testing.assert_almost_equal(ootf_HLG_BT2100_1(E), F_D, decimal=7)
E = np.reshape(E, (6, 1))
F_D = np.reshape(F_D, (6, 1))
np.testing.assert_almost_equal(ootf_HLG_BT2100_1(E), F_D, decimal=7)
E = np.array([0.25, 0.50, 0.75])
F_D = np.array([213.01897444, 426.03794887, 639.05692331])
np.testing.assert_almost_equal(ootf_HLG_BT2100_1(E), F_D, decimal=7)
E = np.tile(E, (6, 1))
F_D = np.tile(F_D, (6, 1))
np.testing.assert_almost_equal(ootf_HLG_BT2100_1(E), F_D, decimal=7)
E = np.reshape(E, (2, 3, 3))
F_D = np.reshape(F_D, (2, 3, 3))
np.testing.assert_almost_equal(ootf_HLG_BT2100_1(E), F_D, decimal=7)
def test_domain_range_scale_ootf_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_HLG_BT2100_1` definition domain and range scale support.
"""
E = 0.1
F_D = ootf_HLG_BT2100_1(E)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
ootf_HLG_BT2100_1(E * factor), F_D * factor, decimal=7)
@ignore_numpy_errors
def test_nan_ootf_HLG_BT2100_1(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_HLG_BT2100_1` definition nan support.
"""
ootf_HLG_BT2100_1(np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
class TestOotf_HLG_BT2100_2(unittest.TestCase):
"""
Defines :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_HLG_BT2100_2` definition unit tests methods.
"""
def test_ootf_HLG_BT2100_2(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_HLG_BT2100_2` definition.
"""
self.assertAlmostEqual(ootf_HLG_BT2100_2(0.0), 0.0, places=7)
self.assertAlmostEqual(
ootf_HLG_BT2100_2(0.1), 63.095734448019336, places=7)
self.assertAlmostEqual(ootf_HLG_BT2100_2(1.0), 1000.0, places=7)
self.assertAlmostEqual(
ootf_HLG_BT2100_2(0.1, 10000, 1.4), 398.107170553497380, places=7)
a = np.array([
[45.884942278760597, 0.000000000000000, -45.884942278760597],
[-63.095734448019336, -63.095734448019336, -63.095734448019336],
[63.095734448019336, 63.095734448019336, 63.095734448019336],
[51.320396090100672, -51.320396090100672, 51.320396090100672],
], )
np.testing.assert_almost_equal(
ootf_HLG_BT2100_2(
np.array([[0.1, 0.0, -0.1], [-0.1, -0.1, -0.1],
[0.1, 0.1, 0.1], [0.1, -0.1, 0.1]])),
a,
decimal=7)
def test_n_dimensional_ootf_HLG_BT2100_2(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2100.\
ootf_HLG_BT2100_2` definition n-dimensional arrays support.
"""
E = 0.1
F_D = ootf_HLG_BT2100_2(E)
E = np.tile(E, 6)
F_D = np.tile(F_D, 6)
np.testing.assert_almost_equal(ootf_HLG_BT2100_2(E), F_D, decimal=7)
E = np.reshape(E, (2, 3))
F_D = np.reshape(F_D, (2, 3))
np.testing.assert_almost_equal(ootf_HLG_BT2100_2(E), F_D, decimal=7)
E = np.reshape(E, (2, 3, 1))
F_D = np.reshape(F_D, (2, 3, 1))
np.testing.assert_almost_equal(ootf_HLG_BT2100_2(E), F_D, decimal=7)
E = np.reshape(E, (6, 1))
F_D = np.reshape(F_D, (6, 1))
np.testing.assert_almost_equal(ootf_HLG_BT2100_2(E), F_D, decimal=7)
E = np.array([0.25, 0.50, 0.75])
F_D = np.array([213.01897444, 426.03794887, 639.05692331])
np.testing.assert_almost_equal(ootf_HLG_BT2100_2(E), F_D, decimal=7)
E = np.tile(E, (6, 1))
F_D = | np.tile(F_D, (6, 1)) | numpy.tile |
"""
The module 'solver' contains the LeeWaveSolver class, which allows solution of the 2D, steady, linear, lee wave problem.
"""
import numpy as np
from numpy import pi
import matplotlib.pyplot as plt
import xarray as xr
import scipy.fft as fft
import cmocean
class LeeWaveSolver:
"""
A 2D, steady, linear, solver for lee waves
Given user preferences of domain size, topography, background flow, upper boundary type, rotation,
viscosity/diffusivity, and hydrostatic/nonhydrostatic, LeeWaveSolver solves the linear lee wave problem and finds
the wave variables and energy diagnostics.
Attributes
----------
nx : int
Grid size in the horizontal x-direction. Set in class initialisation. Should be even, default: 800
nz : int
Grid size in the vertical z-direction. Set in class initialisation. Should be odd, default: 201
nm : int
Number of modes to be used in Galerkin solver. Set in class initialisation. Should be less than nz, default: 200
H : int
Fluid depth in metres. Set in class initialisation. Default 3000.
L : int
Horizontal domain half-length in metres. Set in class initialisation. Default 20000.
dx : float
Horizontal grid spacing. Set by solver and shouldn't be changed.
x : np.ndarray
Horizontal x coordinate, length nx. Set by solver and shouldn't be changed.
dz : float
Vertical grid spacing. Set by solver and shouldn't be changed.
z : np.ndarray
Vertical z coordinate, length nz. Set by solver and shouldn't be changed.
h_topo : np.ndarray
Topographic height, length nx. Set by method set_topo(), defaults to Gaussian.
U : np.ndarray
Vertical profile of background flow speed, length nz. Set by method set_mean_velocity().
Defaults to a uniform 0.1 m/s.
U_type : str
Type of background flow speed, 'Uniform', 'Linear', or 'Custom'. Set by parameter to set_mean_velocity(),
defaults to 'Uniform'.
N : np.ndarray
Vertical profile of background buoyancy frequency N (stratification), length nz. Set by method
set_mean_stratification(). Defaults to a uniform 0.001 s^{-1}.
uniform_mean : bool
True if background flows are uniform (speeds up solver). False otherwise. Set internally.
f : float
Coriolis parameter (s^{-1}). Set as a parameter to solve(), defaults to 0.
Ah : float
Horizontal Laplacian viscosity (m^2/s). Set as a parameter to solve(), defaults to 1 m^2/s.
Dh : float
Horizontal Laplacian diffusivity (m^2/s). Set as a parameter to solve(), defaults to Ah.
rho_0 : float
Reference density (kg/m^3). Set in initialisation of class. Default 1027 kg/m^3.
hydrostatic : bool
True if using hydrostatic approximation, False otherwise. Set as a parameter to solve(), defaults to False.
open_boundary : bool
True if using a freely radiating upper boundary, False for a rigid lid boundary condition. Set as a parameter
to solve(), defaults to True.
wave_fields : xarray.core.dataset.Dataset
Dataset created by method solve() containing solution wave fields and background flow.
None until solve() is called
diags : xarray.core.dataset.Dataset
Dataset created by method solve() containing 1D and 2D energy diagnostics.
None until solve() is called
Methods
-------
set_topo(topo_type='Gaussian', h0=50, width=1000, k_topo=2 * pi / 5000, k_max=0.01, k_min=0.001,
K0=2.3e-4, L0=1.3e-4, mu=3.5, h_input=None)
Sets the topography according to user preferences.
set_mean_velocity(U_type='Uniform', U_0=0.1, U_H=0.3, U_input=None)
Sets the mean (background) vertical velocity profile according to user preferences.
set_mean_stratification(N_type='Uniform', N_0=0.001, N_H=0.003, N_input=None)
Sets the mean (background) vertical buoyancy frequency (N) profile according to user preferences.
plot_inputs()
Show a plot of the topography, background velocity and stratification profiles.
solve(f=0, open_boundary=True, hydrostatic=True, Ah=1.0, Dh=None)
Solves the given lee wave problem.
plot(array)
Custom plotting function to easily create 1D profiles or 2D pcolormesh plots of an field from wave_fields or
diags
"""
def __init__(self, nx=800, nz=201, nm=200, H=3000, L=20000, rho_0=1027.):
"""
Parameters
----------
nx : int
Grid size in the horizontal x-direction. Should be even, default: 800
nz : int
Grid size in the vertical z-direction. Should be odd, default: 201
nm : int
Number of modes to be used in Galerkin solver. Should be less than nz, default: 200
H : int
Fluid depth in metres, default 3000.
L : int
Horizontal domain half-length in metres, default 20000.
rho_0 : float
Reference density (kg/m^3), default 1027 kg/m^3.
"""
if nx % 2 != 0 or nz % 2 != 1:
raise ValueError('nx should be even and nz should be odd')
# Initialise attributes
self.nx = nx
self.nz = nz
self.nm = nm
self.H = H
self.L = L
self.dx = 2 * self.L / self.nx
self.x = np.linspace(-self.L, self.L - self.dx, self.nx)
self.dz = self.H / self.nz
self.z = np.linspace(0, self.H, self.nz)
self.h_topo = None
self.U = 0.1 * np.ones_like(self.z)
self.U_type = 'Uniform'
self.N = 0.001 * np.ones_like(self.z)
self.uniform_mean = True
self.f = 0.
self.Ah = 0.
self.Dh = 0.
self.rho_0 = float(rho_0)
self.hydrostatic = False
self.open_boundary = True
self.wave_fields = None
self.diags = None
# Call methods to initialise topography and background flow to default.
self.set_topo()
self.set_mean_velocity()
self.set_mean_stratification()
def set_topo(self, topo_type='Gaussian', h0=50., width=1000, k_topo=2 * pi / 5000, k_max=0.01, k_min=0.001,
K0=2.3e-4, L0=1.3e-4, mu=3.5, h_input=None):
"""
Finds topography given by user preference and sets internally as an attribute to the solver.
Parameters
----------
topo_type : str
Type of topography to create.
- 'Gaussian' creates h(x) = h0*exp(-x**2/width**2), uses only h0 and width
- 'WitchOfAgnesi' creates h(x) = h0/(1 + x**2/width**2), uses only h0 and width
- 'Monochromatic' creates h(x) = h0*cos(k_topo*x), uses only h0 and k_topo. If a full number of wavelengths
doesn't fit in the horizontal domain, the domain half-length L and x will be adjusted.
- 'GJ98' creates topography according to the Goff & Jordan (1998) theoretical spectrum. The 2D spectrum is
integrated over cross-stream wavenumbers l to get a 1D spectrum. k_min is the minimum wavelength cutoff,
k_max is the maximum wavelength cutoff, K0 is the rolloff k-wavenumber, L0 is the rolloff l-wavenumber,
mu/2 is the 'slope'. Default parameters are as described for the Drake Passage in
Nikurashin & Ferrari (2010b). The resulting topography is normalised so that the RMS height is h0.
- 'Custom' allows the user to input a topographic profile h(x) in h_input, it must have the same shape as x.
h0 : float
Topographic height (m), used in 'Gaussian', 'WitchOfAgnesi', 'Monochromatic', and 'GJ98' topography types.
Defaults to 50m.
width : float
Topographic width (m), used in 'Gaussian' and 'WitchOfAgnesi' topography types. Defaults to 1000m.
k_topo : float
Topographic wavenumber (rad/m), used in 'Monochromatic' topography. Defaults to 2*pi/5000 rad/m.
k_max : float
Maximum wavenumber cutoff (rad/m), used in 'GJ1998' topography. Usually N/U. Defaults to 0.01 rad/m.
k_min : float
Minimum wavenumber cutoff (rad/m), used in 'GJ1998' topography. Usually f/U. Defaults to 0.001 rad/m.
K0 : float
Rolloff wavenumber in x, used in 'GJ1998' topography. Defaults to 2.3e-4 rad/m.
L0 : float
Rolloff wavenumber in y, used in 'GJ1998' topography. Defaults to 1.3e-4 rad/m.
mu : float
Slope parameter, used in 'GJ1998' topography. Defaults to 3.5.
h_input : np.ndarray
User input topography, length nx. Used in 'Custom' topography
"""
if topo_type == 'Gaussian':
if h0 > self.H:
raise ValueError('Topography height should be less than domain height')
elif width > self.L / 5:
raise ValueError('Topography width is too large compared to the length of domain')
self.h_topo = h0 * np.exp(-self.x ** 2 / width ** 2)
elif topo_type == 'WitchOfAgnesi':
if h0 > self.H:
raise ValueError('Topography height should be less than domain height')
elif width > self.L / 5:
raise ValueError('Topography width is too large compared to the length of domain')
self.h_topo = h0 / (1 + self.x ** 2 / width ** 2)
elif topo_type == 'Monochromatic':
if h0 > self.H:
raise ValueError('Topography height should be less than domain height')
elif k_topo < 2 * pi / self.L:
raise ValueError('Topography width is too large compared to the length of domain')
lam = 2 * pi / k_topo
n = self.L / lam
if round(n) != n:
self.L = lam * round(n)
self.dx = 2 * self.L / self.nx
self.x = np.linspace(-self.L, self.L - self.dx, self.nx)
warnings.warn(
f'Domain width L has been adjusted to {self.L:.2f}m to allow topography with wavelength {lam:.2f}m')
self.h_topo = h0 * np.cos(self.x * k_topo)
elif topo_type == 'GJ98':
if h0 > self.H:
raise ValueError('Topography height should be less than domain height')
self.h_topo = self.__GJ98topo(h0, k_max, k_min, K0, L0, mu)
elif topo_type == 'Custom':
if h_input is None:
raise ValueError('Topography needs to be given in \'h_input\'')
elif len(h_input) != len(self.x):
raise ValueError('\'h_input\' should be the same length as x (solver.x)')
self.h_topo = h_input
self.h_topo -= np.min(self.h_topo)
def set_mean_velocity(self, U_type='Uniform', U_0=0.1, U_H=0.3, U_input=None):
"""
Finds velocity profile given by user preference and sets internally as an attribute to the solver.
Parameters
----------
U_type: str
Type of background velocity profile to create
- 'Uniform' creates U(z) as a uniform profile of length nz with value U_0. Uses only U_0.
- 'Linear' creates U(z) as a linear profile of length nz with bottom value U_0 and surface value U_H.
Uses U_0 and U_H.
- 'Custom' creates a user input velocity profile given by U_input. Must be of length nz. For a strictly 2D
background flow, geostrophic balance requires fU_zz = 0. Be aware of this if you choose a non-constant shear.
U_0 : float
Bottom flow speed (m/s). Used in 'Uniform' and 'Linear' profiles, defaults to 0.1m/s.
U_H : float
Surface flow speed (m/s). Used in 'Linear' profile, defaults to 0.3m/s.
U_input: np.ndarray
User input velocity profile, length nz, used in 'Custom' type.
"""
self.U_type = U_type
if U_type == 'Uniform':
self.U = U_0 * np.ones_like(self.z)
elif U_type == 'Linear':
self.uniform_mean = False
self.U = U_0 + (U_H - U_0) / self.H * self.z
elif U_type == 'Custom':
self.uniform_mean = False
if U_input is None:
raise ValueError('U needs to be given in \'U_input\'')
elif len(U_input) != len(self.z):
raise ValueError('\'U_input\' should be the same length as z (solver.z)')
self.U = U_input
def set_mean_stratification(self, N_type='Uniform', N_0=0.001, N_H=0.003, N_input=None):
"""
Finds buoyancy frequency profile given by user preference and sets internally as an attribute to the solver.
Parameters
----------
N_type: str
Type of background stratification profile to create
- 'Uniform' creates N(z) as a uniform profile of length nz with value N_0. Uses only N_0.
- 'Linear' creates N(z) as a linear profile of length nz with bottom value N_0 and surface value N_H.
Uses N_0 and N_H.
- 'Custom' creates a user input stratification profile given by N_input. Must be of length nz.
N_0 : float
Bottom buoyancy frequency (s^{-1}). Used in 'Uniform' and 'Linear' profiles, defaults to 0.001s^{-1}.
N_H : float
Surface buoyancy frequency (s^{-1}). Used in 'Linear' profile, defaults to 0.003s^{-1}.
N_input: np.ndarray
User input buoyancy frequency profile, length nz, used in 'Custom' type.
"""
if N_type == 'Uniform':
self.N = N_0 * np.ones_like(self.z)
elif N_type == 'Linear':
self.uniform_mean = False
self.N = N_0 + (N_H - N_0) / self.H * self.z
elif N_type == 'Custom':
self.uniform_mean = False
if N_input is None:
raise ValueError('N needs to be given in \'N_input\'')
elif len(N_input) != len(self.z):
raise ValueError('\'N_input\' should be the same length as z (solver.z)')
self.N = N_input
def plot_inputs(self):
""" Show a plot of the topography, background velocity and stratification profiles."""
plt.rcParams.update({'font.size': 20})
fig, axes = plt.subplots(1, 3, gridspec_kw={'width_ratios': [3, 1, 1]}, figsize=(30, 7))
axes[0].fill(np.append(np.insert(self.x, 0, -self.L), self.L),
np.append(np.insert(self.h_topo, 0, np.min(self.h_topo)), np.min(self.h_topo)), 'k')
axes[0].set_xlabel('x [m]')
axes[0].set_ylabel('Height above bottom [m]')
axes[0].set_ylim([0, self.H])
axes[0].set_xlim([-self.L, self.L])
axes[1].plot(self.U, self.z, 'r', linewidth=3)
axes[1].set_xlabel('U [m/s]')
# axes[1].set_ylabel('Height above bottom [m]')
axes[1].set_ylim([0, self.H])
axes[2].plot(self.N, self.z, 'b', linewidth=3)
axes[2].set_xlabel('N [1/s]')
# axes[2].set_ylabel('Height above bottom [m]')
axes[2].set_ylim([0, self.H])
fig.suptitle('Topography and background flow input to the lee wave solver')
plt.show()
def solve(self, f=0, open_boundary=True, hydrostatic=True, Ah=1.0, Dh=None):
"""
Method to solve linear lee wave problem with the previously set/ default flow and domain. Creates the solver
attributes 'wave_fields' and 'diags'.
Parameters
----------
f : float
Coriolis parameter (s^{-1}), defaults to 0.
open_boundary : bool
True if using a freely radiating upper boundary, False for a rigid lid boundary condition. Defaults to True.
hydrostatic : bool
True if using hydrostatic approximation, False otherwise. Defaults to False.
Ah : float
Horizontal Laplacian viscosity (m^2/s). Defaults to 1 m^2/s.
Dh : float
Horizontal Laplacian diffusivity (m^2/s). Defaults to Ah.
"""
self.f = float(f)
self.open_boundary = open_boundary
self.hydrostatic = hydrostatic
self.Ah = float(Ah)
self.Dh = float(Dh) if Dh is not None else float(Ah)
# First check the inputs are consistent, raise errors or warn if not:
self.__check_inputs()
# Find the transformed topography and truncated and full wavenumber vectors
k_full, k_trunc, h_topo_hat, h_topo_hat_trunc = self.__transform_topo()
# Define the coefficients of the ODE
P, Q = self.__ODEcoeffs(k_trunc)
# Solve for the Fourier transformed wave fields
psi_hat, u_hat, v_hat, w_hat, b_hat, p_hat = self.__fourier_solve(k_full, k_trunc, h_topo_hat_trunc, P, Q)
# Invert to give the real space wave fields
psi = self.__inverse_transform(psi_hat)
u = self.__inverse_transform(u_hat)
v = self.__inverse_transform(v_hat)
w = self.__inverse_transform(w_hat)
b = self.__inverse_transform(b_hat)
p = self.__inverse_transform(p_hat)
# Get 2D background fields
if self.uniform_mean:
U_2D = np.ones((self.nx, self.nz)) * self.U
N2_2D = np.ones((self.nx, self.nz)) * self.N ** 2
B_2D = np.cumsum(N2_2D, 1) * self.dz
else:
U_2D = np.tile(np.expand_dims(self.U, 0), [self.nx, 1])
N2_2D = np.tile(np.expand_dims(self.N ** 2, 0), [self.nx, 1])
B_2D = np.cumsum(N2_2D, 1) * self.dz
# Package everything into a datasets for output
self.wave_fields = self.__make_wave_fields_dataset(k_full, psi, u, v, w, b, p, h_topo_hat, psi_hat, u_hat,
v_hat, w_hat, b_hat, p_hat, U_2D, B_2D, N2_2D)
self.diags = self.__make_diags_dataset()
def plot(self, array, vmin = 'default',vmax='default'):
"""
Simple plotting function to plot output variables from solver.
Uses matplotlib.pyplot and xarray plotting functionality. If array given is 1D, creates a line plot.
If array is 2D, creates a pcolormesh plot, with topography shown.
Parameters
----------
array : xarray.core.dataset.Dataset
Output array created from calling solve(). Can be an array from 'wave_variables' or 'diags'.
"""
plt.rcParams.update({'font.size': 14})
if vmin == 'default':
vmin = array.min().values
if vmax == 'default':
vmax = array.max().values
if len(array.dims) == 0:
print('Needs more than one dimension to make a plot')
elif len(array.dims) == 1:
fig, ax = plt.subplots(1, 1, figsize=(5, 10))
array.plot(y='z', linewidth=2, ax=ax)
else:
fig, ax = plt.subplots(1, 1, figsize=(15, 7))
if (array.min() < 0) & (array.max() > 0):
# Want a symmetric colormap
cmap = cmocean.cm.balance
array.plot(y='z', ax=ax, cmap=cmap)
ax.fill(np.append(np.insert(self.x, 0, -self.L), self.L),
np.append(np.insert(self.h_topo, 0, np.min(self.h_topo)), np.min(self.h_topo)), 'k')
ax.set_ylim([np.min(self.h_topo), self.H])
else:
cmap = cmocean.cm.thermal
array.plot(y='z', ax=ax, cmap=cmap, vmin=vmin, vmax=vmax)
ax.fill(np.append(np.insert(self.x, 0, -self.L), self.L),
np.append(np.insert(self.h_topo, 0, np.min(self.h_topo)), np.min(self.h_topo)), 'k')
ax.set_ylim([np.min(self.h_topo), self.H])
plt.show()
def __GJ98topo(self, h0=25, k_max=0.01, k_min=0.001, K0=2.3e-4, L0=1.3e-4, mu=3.5):
""" Called by set_topo(), creates a realisation of the Goff Jordan (1998) theoretical topography spectrum."""
# Define spectral vectors:
l = pi / self.L * np.arange(-self.nx / 2, self.nx / 2)
k = pi / self.L * np.arange(-self.nx / 2, self.nx / 2)
lm, km = | np.meshgrid(l, k) | numpy.meshgrid |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.