prompt
stringlengths 19
879k
| completion
stringlengths 3
53.8k
| api
stringlengths 8
59
|
|---|---|---|
'''
Basic models for decomposing large-scale stacked profiles
'''
import numpy as np
from astropy.modeling import models, fitting
from scipy.interpolate import InterpolatedUnivariateSpline
from scipy.special import erf
from scipy.optimize import curve_fit
from functools import partial
from astropy.convolution import convolve
from .spectral_fitting import gauss_model_discrete
def fit_2gaussian(vels, spectrum):
'''
Fit a 2 Gaussian model with the means tied.
.. todo:: Allow passing sigma for weighting in the fit.
'''
max_vel = vels[np.argmax(spectrum)]
specmax = spectrum.max()
# Estimate the inner width from the HWHM
sigma_est = find_hwhm(vels, spectrum)[0]
# Use this as the narrow estimate, and let the wide guess be 3x
g_HI_init = models.Gaussian1D(amplitude=0.75 * specmax, mean=max_vel,
stddev=sigma_est) + \
models.Gaussian1D(amplitude=0.25 * specmax, mean=max_vel,
stddev=3 * sigma_est)
# Force to the same mean
def tie_mean(mod):
return mod.mean_0
g_HI_init.mean_1.tied = tie_mean
fit_g = fitting.LevMarLSQFitter()
g_HI = fit_g(g_HI_init, vels, spectrum)
# The covariance matrix is hidden away... tricksy
cov = fit_g.fit_info['param_cov']
parnames = [n for n in g_HI.param_names if n not in ['mean_1']]
parvals = [v for (n, v) in zip(g_HI.param_names, g_HI.parameters)
if n in parnames]
if cov is not None:
chan_width = np.diff(vels[:2])[0]
parerrs = []
for name, var in zip(parnames, np.diag(cov)):
if "mean" in name or "stddev" in name:
# Add the finite channel width in quadrature
stderr = np.sqrt(var + (0.5 * chan_width)**2)
else:
stderr = np.sqrt(var)
parerrs.append(stderr)
else:
parerrs = [np.NaN] * len(parnames)
return parvals, parerrs, cov, parnames, g_HI
def fit_gaussian(vels, spectrum, p0=None, sigma=None, use_discrete=False,
kernel=None, add_chan_width_err=True):
'''
Fit a Gaussian model.
Parameters
----------
sigma : `~astropy.units.Quantity`, optional
Pass a single value to be used for all points or an array of values
equal to the size of vels and spectrum. These are used to define
weights in the fit, and the weights as defined as 1 / sigma, as is
used in `~scipy.optimize.curve_fit`.
'''
if hasattr(vels, 'unit'):
vel_unit = vels.unit
else:
vel_unit = 1.
if hasattr(vels, 'unit'):
spec_unit = spectrum.unit
else:
spec_unit = 1.
if p0 is None:
max_vel = vels[np.argmax(spectrum)]
specmax = spectrum.max()
# Estimate the inner width from the HWHM
sigma_est = find_hwhm(vels, spectrum)[0]
p0 = (specmax.value, max_vel.value, sigma_est)
else:
specmax, max_vel, sigma_est = p0
if sigma is not None:
if hasattr(sigma, 'size'):
if sigma.size > 1:
if sigma.size != vels.size:
raise ValueError("sigma must match the data shape when "
"multiple values are given.")
weights = 1 / np.abs(sigma.value)
else:
# A quantity will still have a `size` attribute with one
# element
weights = 1 / np.array([np.abs(sigma.value)] * len(vels))
else:
weights = 1 / np.array([np.abs(sigma)] * len(vels))
else:
weights = None
# Use this as the narrow estimate, and let the wide guess be 3x
g_init = models.Gaussian1D(amplitude=specmax, mean=max_vel,
stddev=sigma_est)
if use_discrete:
# Don't use the astropy fitting for the discrete model
# Though the astropy fitter is using something quite similar
# to this, anyways.
if kernel is not None:
def spectral_model(vels, amp, mean, stddev):
model = gauss_model_discrete(vels, amp=amp, stddev=stddev,
mean=mean)
return convolve(model, kernel)
else:
def spectral_model(vels, amp, mean, stddev):
return gauss_model_discrete(vels, amp=amp, stddev=stddev,
mean=mean)
out = curve_fit(spectral_model,
vels, spectrum, p0=p0,
sigma=sigma * np.ones_like(vels),
absolute_sigma=True, maxfev=100000)
g_fit = models.Gaussian1D(amplitude=out[0][0] * spec_unit,
mean=out[0][1] * vel_unit,
stddev=out[0][2] * vel_unit)
cov = out[1]
parerrs = np.sqrt(np.diag(out[1]))
else:
fit_g = fitting.LevMarLSQFitter()
g_fit = fit_g(g_init, vels, spectrum, weights=weights)
# The covariance matrix is hidden away... tricksy
cov = fit_g.fit_info['param_cov']
if cov is None:
cov = np.zeros((3, 3)) * np.NaN
parnames = g_fit.param_names
parvals = g_fit.parameters
if cov is not None:
chan_width = np.diff(vels[:2])[0].value
parerrs = []
for name, var, val in zip(parnames, np.diag(cov), parvals):
# print(name, var, val)
if "mean" in name or "stddev" in name and add_chan_width_err:
# Add the finite channel width in quadrature
# print(var, chan_width)
# print(np.diag(cov))
stderr = np.sqrt(var + (0.35 * chan_width)**2)
else:
stderr = np.sqrt(var)
parerrs.append(stderr)
else:
parerrs = [np.NaN] * len(parnames)
# Sometimes the width is negative
parvals[-1] = | np.abs(parvals[-1]) | numpy.abs |
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
import numpy as np
import sys
sys.path.append('/home/groups/ZuckermanLab/copperma/cell/celltraj')
import celltraj
import h5py
import pickle
import os
import subprocess
import time
sys.path.append('/home/groups/ZuckermanLab/copperma/msmWE/BayesianBootstrap')
import bootstrap
import umap
import pyemma.coordinates as coor
import scipy
modelList=['PBS_17nov20','EGF_17nov20','HGF_17nov20','OSM_17nov20','BMP2_17nov20','IFNG_17nov20','TGFB_17nov20']
nmodels=len(modelList)
modelSet=[None]*nmodels
for i in range(nmodels):
modelName=modelList[i]
objFile=modelName+'_coords.obj'
objFileHandler=open(objFile,'rb')
modelSet[i]=pickle.load(objFileHandler)
objFileHandler.close()
wctm=celltraj.cellTraj()
fileSpecifier='/home/groups/ZuckermanLab/copperma/cell/live_cell/mcf10a/batch_17nov20/*_17nov20.h5'
print('initializing...')
wctm.initialize(fileSpecifier,modelName)
nfeat=modelSet[0].Xf.shape[1]
Xf=np.zeros((0,nfeat))
indtreatment=np.array([])
indcellSet=np.array([])
for i in range(nmodels):
Xf=np.append(Xf,modelSet[i].Xf,axis=0)
indtreatment=np.append(indtreatment,i*np.ones(modelSet[i].Xf.shape[0]))
indcellSet=np.append(indcellSet,modelSet[i].cells_indSet)
indtreatment=indtreatment.astype(int)
indcellSet=indcellSet.astype(int)
Xpca,pca=wctm.get_pca_fromdata(Xf,var_cutoff=.9)
wctm.Xpca=Xpca
wctm.pca=pca
for i in range(nmodels):
indsf=np.where(indtreatment==i)[0]
modelSet[i].Xpca=Xpca[indsf,:]
all_trajSet=[None]*nmodels
for i in range(nmodels):
modelSet[i].get_unique_trajectories()
all_trajSet[i]=modelSet[i].trajectories.copy()
self=wctm
for trajl in [8]: #,2,3,4,5,6,7,8,9,10,12,14,16,18,20,25,30,26]:
wctm.trajl=trajl
Xpcat=np.zeros((0,pca.ndim*trajl))
indtreatment_traj=np.array([])
indstack_traj=np.array([])
indframes_traj=np.array([])
cellinds0_traj=np.array([])
cellinds1_traj=np.array([])
for i in range(nmodels):
modelSet[i].trajectories=all_trajSet[i].copy()
modelSet[i].trajl=trajl
modelSet[i].traj=modelSet[i].get_traj_segments(trajl)
data=modelSet[i].Xpca[modelSet[i].traj,:]
data=data.reshape(modelSet[i].traj.shape[0],modelSet[i].Xpca.shape[1]*trajl)
Xpcat=np.append(Xpcat,data,axis=0)
indtreatment_traj=np.append(indtreatment_traj,i*np.ones(data.shape[0]))
indstacks=modelSet[i].cells_imgfileSet[modelSet[i].traj[:,0]]
indstack_traj=np.append(indstack_traj,indstacks)
indframes=modelSet[i].cells_frameSet[modelSet[i].traj[:,0]]
indframes_traj=np.append(indframes_traj,indframes)
cellinds0=modelSet[i].traj[:,0]
cellinds0_traj=np.append(cellinds0_traj,cellinds0)
cellinds1=modelSet[i].traj[:,-1]
cellinds1_traj=np.append(cellinds1_traj,cellinds1)
cellinds0_traj=cellinds0_traj.astype(int)
cellinds1_traj=cellinds1_traj.astype(int)
for neigen in [2]: #[1,2,3,4,5]:
reducer=umap.UMAP(n_neighbors=200,min_dist=0.1, n_components=neigen, metric='euclidean')
trans = reducer.fit(Xpcat)
x=trans.embedding_
indst=np.arange(x.shape[0]).astype(int)
wctm.Xtraj=x.copy()
wctm.indst=indst.copy()
indconds=np.array([[0,1],[2,3],[4,5]]).astype(int)
ncond=3
fl=12
fu=96
nbinstotal=15.*15.
indstw=np.where(np.logical_and(indframes_traj[indst]<fu,indframes_traj[indst]>fl))[0]
probSet=[None]*nmodels
avoverlapSet=np.zeros(ncond)
prob1,edges=np.histogramdd(x[indstw,:],bins=int(np.ceil(nbinstotal**(1./neigen))),density=True)
for icond in range(ncond):
imf1=indconds[icond,0]
imf2=indconds[icond,1]
inds_imf1=np.where(indstack_traj==imf1)[0]
inds_imf2=np.where(indstack_traj==imf2)[0]
inds_cond=np.append(inds_imf1,inds_imf2)
for imf in range(nmodels):
indstm=np.where(indtreatment_traj==imf)[0]
indstm_cond=np.intersect1d(indstm,inds_cond)
xt=x[indstm_cond,0:neigen]
indg=np.where(np.logical_not(np.logical_or(np.isnan(xt[:,0]),np.isinf(xt[:,0]))))[0]
xt=xt[indg]
prob,edges2=np.histogramdd(xt,bins=edges,density=True) #for d=1
prob=prob/np.sum(prob)
probSet[imf]=prob.copy()
poverlapMatrix=np.zeros((nmodels,nmodels))
for i in range(nmodels):
for j in range(nmodels):
probmin=np.minimum(probSet[i],probSet[j])
poverlapMatrix[i,j]=np.sum(probmin)
avoverlapSet[icond]=np.mean(poverlapMatrix[np.triu_indices(nmodels,1)])
sys.stdout.write('avoverlap: '+str(avoverlapSet[0])+' '+str(avoverlapSet[1])+' '+str(avoverlapSet[2])+'\n')
#np.savetxt('avoverlapSet_UMAP_trajl'+str(trajl)+'_ndim'+str(neigen)+'_19feb21.dat',avoverlapSet)
for i in range(nmodels):
modelSet[i].trajectories=all_trajSet[i].copy()
indconds=np.array([[0,1],[2,3],[4,5]]).astype(int)
ncond=3
probSet=[None]*nmodels
sigdxSet=np.zeros(ncond)
sigxSet=np.zeros(ncond)
dxSet=np.zeros(ncond)
x0=np.zeros((0,neigen))
x1=np.zeros((0,neigen))
for icond in range(ncond):
imf1=indconds[icond,0]
imf2=indconds[icond,1]
inds_imf1=np.where(indstack_traj==imf1)[0]
inds_imf2=np.where(indstack_traj==imf2)[0]
inds_cond=np.append(inds_imf1,inds_imf2)
for imf in range(nmodels):
indstm=np.where(indtreatment_traj==imf)[0]
indstm_cond=np.intersect1d(indstm,inds_cond)
modelSet[imf].Xtraj=x[indstm,0:neigen]
indstm_cond_model=indstm_cond-np.min(indstm) #index in model
modelSet[imf].get_trajectory_steps(inds=None,get_trajectories=False,traj=modelSet[imf].traj[indstm_cond_model,:],Xtraj=modelSet[imf].Xtraj[indstm_cond_model,:])
x0=np.append(x0,modelSet[imf].Xtraj0,axis=0)
x1=np.append(x1,modelSet[imf].Xtraj1,axis=0)
g0=np.logical_not(np.logical_or(np.isnan(x0[:,0]),np.isinf(x0[:,0])))
g1=np.logical_not(np.logical_or(np.isnan(x1[:,0]),np.isinf(x1[:,0])))
indg=np.where(np.logical_and(g0,g1))[0]
x0=x0[indg,:]
x1=x1[indg,:]
avdx=np.median(x1-x0,axis=0)
avdxsq=np.median(np.power(x1-x0,2),axis=0)
sigdx=np.sqrt(np.sum(avdxsq-np.power(avdx,2)))
avx=np.mean(x0,axis=0)
avxsq=np.mean(np.power(x0-avx,2),axis=0)
sigx=np.sqrt(np.sum(avxsq))
sys.stdout.write('sigx: '+str(sigx)+' sigdx: '+str(sigdx)+'\n')
dxSet[icond]=sigdx/sigx #np.sum(dxcorr[0:4]) #np.mean(dr[inds_xr])
sigxSet[icond]=sigx
sigdxSet[icond]=sigdx
sys.stdout.write('dx ratio: '+str(dxSet[0])+' '+str(dxSet[1])+' '+str(dxSet[2])+'\n')
#np.savetxt('dxratioSet_UMAP_trajl'+str(trajl)+'_ndim'+str(neigen)+'_19feb21.dat',dxSet)
fl=12
fu=96 #frames for time window
indstw=np.where(np.logical_and(indframes_traj<fu,indframes_traj>fl))[0]
inds_imft=np.array([])
for imf in range(5):
inds_imft=np.append(inds_imft,np.where(indstack_traj==imf)[0])
for i in range(nmodels):
modelSet[i].trajectories=all_trajSet[i].copy()
inds_imft=inds_imft.astype(int)
inds_imfv=np.where(indstack_traj==5)[0]
inds_test=np.intersect1d(indstw,inds_imft)
inds_val=np.intersect1d(indstw,inds_imfv)
for n_clusters in [10,50,100,200]:
wctm.cluster_trajectories(n_clusters,x=x)
entpSet=np.zeros(nmodels)
for i in range(nmodels):
indstm=np.where(indtreatment_traj==i)[0]
modelSet[i].Xtraj=x[indstm,0:neigen]
indstm_test=np.intersect1d(indstm,inds_test)
indstm_test_model=indstm_test-np.min(indstm) #index in model
modelSet[i].get_trajectory_steps(inds=None,get_trajectories=False,traj=modelSet[i].traj[indstm_test_model,:],Xtraj=modelSet[i].Xtraj[indstm_test_model,:])
x0=modelSet[i].Xtraj0
x1=modelSet[i].Xtraj1
wctm.get_transition_matrix(x0,x1)
indstm_val=np.intersect1d(indstm,inds_val)
indstm_val_model=indstm_val-np.min(indstm) #index in model
modelSet[i].get_trajectory_steps(inds=None,get_trajectories=False,traj=modelSet[i].traj[indstm_val_model,:],Xtraj=modelSet[i].Xtraj[indstm_val_model,:])
x0v=modelSet[i].Xtraj0
x1v=modelSet[i].Xtraj1
entp=wctm.get_path_entropy_2point(x0v,x1v,exclude_stays=True)
entpSet[i]=entp
sys.stdout.write('mean entp across treatments: '+str(np.mean(entpSet))+'\n')
#np.savetxt('entpSet_UMAP_trajl'+str(trajl)+'_ndim'+str(neigen)+'_nc'+str(n_clusters)+'_19feb21.dat',entpSet)
for i in range(nmodels):
modelSet[i].trajectories=all_trajSet[i].copy()
dlfkj
import scipy
knn=200
dxSet=np.zeros((nmodels,n_clusters))
nt=5
xbins=np.arange(nt)*.5
xbins_spl=np.linspace(xbins[0],xbins[-1],100)
clusters=wctm.clusterst
for i in range(nmodels):
for iclust in range(n_clusters):
xc=np.array([clusters.clustercenters[iclust,:]])
dmatr=wctm.get_dmat(modelSet[i].Xtraj,xc) #get closest cells to cluster center
indr=np.argsort(dmatr[:,0])
indr=indr[0:knn]
cellindsr=modelSet[i].traj[indr,-1]
modelSet[i].get_unique_trajectories(cell_inds=cellindsr)
try:
dxcorr=modelSet[i].get_dx_tcf(trajectories=modelSet[i].trajectories)
except:
dxcorr=np.ones(nt)*np.nan
if dxcorr.size<nt:
dxcorr_r=np.ones(nt)*np.nan
dxcorr_r[0:dxcorr.size]=dxcorr
dxcorr=dxcorr_r
spl=scipy.interpolate.interp1d(xbins,dxcorr[0:nt])
dxcorr_spl=spl(xbins_spl)
dxSet[i,iclust]=np.trapz(dxcorr_spl/dxcorr_spl[0],x=xbins_spl) #np.sum(dxcorr[0:4]) #np.mean(dr[inds_xr])
#stdxSet[iclust,icond]=np.std(dr[inds_xr])
plt.figure(figsize=(7,12))
nbins=10
plt.subplot(4,2,1)
vdist1,xedges1,yedges1=np.histogram2d(clusters.clustercenters[:,0],clusters.clustercenters[:,1],bins=nbins,weights=np.mean(dxSet,axis=0))
norm1,xedges1,yedges1=np.histogram2d(clusters.clustercenters[:,0],clusters.clustercenters[:,1],bins=[xedges1,yedges1])
vdist1=np.divide(vdist1,norm1)
indnan=np.where(np.isnan(vdist1))
indgood=np.where(np.logical_not(np.isnan(vdist1)))
xedges1c=.5*(xedges1[1:]+xedges1[0:-1])
yedges1c=.5*(yedges1[1:]+yedges1[0:-1])
xx,yy=np.meshgrid(xedges1c,yedges1c)
#levels=np.linspace(np.min(vdist1[indgood]),np.max(vdist1[indgood]),20)
levels=np.linspace(.1,.55,20)
plt.contourf(xx,yy,vdist1.T,cmap=plt.cm.jet,levels=levels)
cbar=plt.colorbar()
cbar.set_label('repolarization time (hrs)')
plt.title('average')
plt.pause(.1)
plt.axis('off')
for i in range(nmodels):
plt.subplot(4,2,i+2)
vdist1,xedges1,yedges1=np.histogram2d(clusters.clustercenters[:,0],clusters.clustercenters[:,1],bins=nbins,weights=dxSet[i,:])
norm1,xedges1,yedges1=np.histogram2d(clusters.clustercenters[:,0],clusters.clustercenters[:,1],bins=[xedges1,yedges1])
vdist1=np.divide(vdist1,norm1)
indnan=np.where(np.isnan(vdist1))
indgood=np.where(np.logical_not(np.isnan(vdist1)))
xedges1c=.5*(xedges1[1:]+xedges1[0:-1])
yedges1c=.5*(yedges1[1:]+yedges1[0:-1])
xx,yy=np.meshgrid(xedges1c,yedges1c)
plt.contourf(xx,yy,vdist1.T,cmap=plt.cm.jet,levels=levels)
#plt.xlabel('UMAP 1')
#plt.ylabel('UMAP 2')
plt.axis('off')
plt.title(tmSet[i])
plt.pause(.1)
plt.savefig('mcf10a_repolarization_24feb21.png')
knn=50
n_clusters=200
wctm.cluster_trajectories(n_clusters,x=x)
clusters=wctm.clusterst
dxs=np.zeros((nmodels,n_clusters,2))
for i in range(nmodels):
indstm=np.where(indtreatment_traj==i)[0]
modelSet[i].Xtraj=x[indstm,0:neigen]
indstm_model=indstm-np.min(indstm) #index in model
modelSet[i].get_trajectory_steps(inds=None,get_trajectories=False,traj=modelSet[i].traj[indstm_model,:],Xtraj=modelSet[i].Xtraj[indstm_model,:])
x0=modelSet[i].Xtraj0
x1=modelSet[i].Xtraj1
dx=x1-x0
for iclust in range(n_clusters):
xc=np.array([clusters.clustercenters[iclust,:]])
dmatr=wctm.get_dmat(modelSet[i].Xtraj[modelSet[i].inds_trajp1[:,-1],:],xc) #get closest cells to cluster center
indr=np.argsort(dmatr[:,0])
indr=indr[0:knn]
cellindsr=modelSet[i].traj[[modelSet[i].inds_trajp1[indr,-1]],-1]
dxs[i,iclust,:]=np.mean(dx[indr,:],axis=0)
tmSet=['PBS','EGF','HGF','OSM','BMP2','IFNG','TGFB']
nbins=15
fl=12
fu=96 #frames for time window
indstw=np.where(np.logical_and(indframes_traj[indst]<fu,indframes_traj[indst]>fl))[0]
probSet=[None]*nmodels
plt.subplot(4,2,1)
prob1,xedges1,yedges1=np.histogram2d(x[indstw,0],x[indstw,1],bins=nbins,density=True)
xx,yy=np.meshgrid(xedges1[1:],yedges1[1:])
#prob1=prob1/np.sum(prob1)
#levels=np.linspace(0,.09,100)
levels=np.linspace(0,np.max(prob1),100)
#levels=np.append(levels,1.)
cs=plt.contourf(xx,yy,prob1.T,levels=levels,cmap=plt.cm.jet)
#plt.clim(0,0.03)
cs.cmap.set_over('darkred')
cbar1=plt.colorbar()
cbar1.set_label('prob density')
plt.title('combined')
plt.axis('off')
for imf in range(nmodels):
tm=modelList[imf][0:4]
indstm=np.where(indtreatment_traj==imf)[0]
indstwm=np.intersect1d(indstm,indstw)
prob,xedges2,yedges2=np.histogram2d(x[indstwm,0],x[indstwm,1],bins=[xedges1,yedges1],density=True)
#prob=prob/np.sum(prob)
probSet[imf]=prob.copy()
plt.subplot(4,2,imf+2)
#levels=np.linspace(0,np.max(prob),100)
cs=plt.contourf(xx,yy,prob.T,levels=levels,cmap=plt.cm.jet,extend='both')
#plt.clim(0,0.03)
cs.cmap.set_over('darkred')
plt.axis('off')
plt.pause(.1)
dxsav=np.mean(dxs,axis=0)
plt.subplot(4,2,1)
plt.title('average')
plt.axis('off')
for ic in range(n_clusters):
ax=plt.gca()
ax.arrow(clusters.clustercenters[ic,0],clusters.clustercenters[ic,1],dxsav[ic,0],dxsav[ic,1],head_width=.1,linewidth=.5,color='white',alpha=1.0)
for i in range(nmodels):
plt.subplot(4,2,i+2)
ax=plt.gca()
for ic in range(n_clusters):
ax.arrow(clusters.clustercenters[ic,0],clusters.clustercenters[ic,1],dxs[i,ic,0],dxs[i,ic,1],head_width=.1,linewidth=.5,color='white',alpha=1.0)
#plt.xlabel('UMAP 1')
#plt.ylabel('UMAP 2')
plt.axis('off')
#plt.title(tmSet[i])
plt.pause(.1)
plt.savefig('mcf10a_prob_flows_24feb21.png')
plt.figure(figsize=(8,6))
nbins=15
fl=12
fu=96 #frames for time window
indstw=np.where(np.logical_and(indframes_traj[indst]<fu,indframes_traj[indst]>fl))[0]
probSet=[None]*nmodels
prob1,xedges1,yedges1=np.histogram2d(x[indstw,0],x[indstw,1],bins=nbins,density=True)
xx,yy=np.meshgrid(xedges1[1:],yedges1[1:])
levels=np.linspace(0,np.max(prob1),100)
for imf in range(nmodels):
indstm=np.where(indtreatment_traj==imf)[0]
indstwm=np.intersect1d(indstm,indstw)
prob,xedges2,yedges2=np.histogram2d(x[indstwm,0],x[indstwm,1],bins=[xedges1,yedges1],density=True)
cs=plt.contourf(xx,yy,prob.T,levels=levels,cmap=plt.cm.jet,extend='both')
#plt.clim(0,0.03)
cs.cmap.set_over('darkred')
#cbar1=plt.colorbar()
#cbar1.set_label('prob density')
plt.axis('off')
plt.pause(.1)
ax=plt.gca()
for ic in range(n_clusters):
ax.arrow(clusters.clustercenters[ic,0],clusters.clustercenters[ic,1],dxs[imf,ic,0],dxs[imf,ic,1],head_width=.1,linewidth=.5,color='white',alpha=1.0)
plt.pause(1)
plt.savefig(tmSet[imf]+'_probflows_tl8_2mar21.png')
plt.clf()
#plot with flows and trajectories
nbins=15
fl=12
fu=96 #frames for time window
indstw=np.where(np.logical_and(indframes_traj[indst]<fu,indframes_traj[indst]>fl))[0]
probSet=[None]*nmodels
prob1,xedges1,yedges1=np.histogram2d(x[indstw,0],x[indstw,1],bins=nbins,density=True)
xx,yy=np.meshgrid(xedges1[1:],yedges1[1:])
levels=np.linspace(0,np.max(prob1),100)
nt=10
minl=24
ctrajSet=[48523,23315,48696,32932,18054,41460,20248]
for imf in [4]: #range(nmodels-1,-1,-1):
modelSet[imf].visual=True
indstm=np.where(indtreatment_traj==imf)[0]
indstwm=np.intersect1d(indstm,indstw)
traj_lengths=np.array([])
for itraj in range(len(modelSet[imf].trajectories)):
traj_lengths=np.append(traj_lengths,modelSet[imf].trajectories[itraj].size)
indtrajs=np.where(traj_lengths>=minl)[0]
#indr=np.random.choice(indtrajs.size,nt,replace=False)
indr=np.arange(indtrajs.size-1,-1,-1).astype(int)
for itrajr in indr:
cell_traj=modelSet[imf].trajectories[indtrajs[itrajr]]
if cell_traj[-1]==ctrajSet[imf]:
plt.figure(figsize=(8,6))
xt,inds_traj=get_Xtraj_celltrajectory(modelSet[imf],cell_traj,Xtraj=None,traj=None)
prob,xedges2,yedges2=np.histogram2d(x[indstwm,0],x[indstwm,1],bins=[xedges1,yedges1],density=True)
cs=plt.contourf(xx,yy,prob.T,levels=levels,cmap=plt.cm.Greys,extend='both')
#plt.clim(0,0.03)
cs.cmap.set_over('black')
#cbar1=plt.colorbar()
#cbar1.set_label('prob density')
plt.axis('off')
ax=plt.gca()
for ic in range(n_clusters):
ax.arrow(clusters.clustercenters[ic,0],clusters.clustercenters[ic,1],dxs[imf,ic,0],dxs[imf,ic,1],head_width=.1,linewidth=.5,color='goldenrod',alpha=1.0) #.2,.75
for itt in range(xt.shape[0]-1):
t=modelSet[imf].cells_frameSet[cell_traj[itt+trajl-1]]*.5
ax.arrow(xt[itt,0],xt[itt,1],xt[itt+1,0]-xt[itt,0],xt[itt+1,1]-xt[itt,1],head_width=.2,linewidth=1.0,color=plt.cm.winter(1.*itt/xt.shape[0]),alpha=1.0) #.4,1.5
t0=modelSet[imf].cells_frameSet[cell_traj[0]]*.5
tf=modelSet[imf].cells_frameSet[cell_traj[-1]]*.5
plt.title('t0='+str(t0)+' tf='+str(tf))
plt.pause(1)
plt.savefig(tmSet[imf]+'_probflows_tl8_c'+str(cell_traj[-1])+'_4mar21.png')
plt.close()
show_cells(modelSet[imf],cell_traj)
plt.savefig(tmSet[imf]+'_celltraj_tl8_c'+str(cell_traj[-1])+'_4mar21.png')
plt.close()
def get_Xtraj_celltrajectory(self,cell_traj,Xtraj=None,traj=None): #traj and
if traj is None:
traj=self.traj
if Xtraj is None:
x=self.Xtraj
else:
x=Xtraj
ntraj=cell_traj.size
neigen=x.shape[1]
xt=np.zeros((0,neigen))
inds_traj=np.array([])
for itraj in range(ntraj-self.trajl):
test=cell_traj[itraj:itraj+trajl]
res = (traj[:, None] == test[np.newaxis,:]).all(-1).any(-1)
if np.sum(res)==1:
indt=np.where(res)[0][0]
xt=np.append(xt,np.array([x[indt,:]]),axis=0)
inds_traj=np.append(inds_traj,indt)
return xt,inds_traj.astype(int)
def show_cells(self,cell_inds,show_segs=False):
if self.visual:
ncells=cell_inds.size
nb=int(np.ceil(np.sqrt(ncells)))
fig, ax = plt.subplots(nrows=nb, ncols=nb, figsize=(12, 16), sharex='all', sharey='all')
#plt.figure(figsize=(12,16))
#fig,ax=plt.subplots(nrows=nb,ncols=2,sharex='all',sharey='all')
inds=np.arange(nb*nb).astype(int)
inds2d=np.unravel_index(inds,(nb,nb))
inds2d1b=inds2d[1].reshape(nb,nb)
for ir in range(1,nb,2):
inds2d1b[ir]=np.flip(inds2d1b[ir])
inds2d=(inds2d[0],inds2d1b.flatten())
for ic in range(nb*nb):
if ic<ncells:
self.get_cellborder_images(indcells=np.array([cell_inds[ic]]),bordersize=40)
imgcell=self.cellborder_imgs[0]
mskcell=self.cellborder_msks[0]
fmskcell=self.cellborder_fmsks[0]
ccborder,csborder=self.get_cc_cs_border(mskcell,fmskcell)
img_fg=ax[inds2d[0][ic],inds2d[1][ic]].imshow(np.ma.masked_where(fmskcell == 0, imgcell),cmap=plt.cm.seismic,clim=(-10,10),alpha=1.0)
img_bg=ax[inds2d[0][ic],inds2d[1][ic]].imshow( | np.ma.masked_where(fmskcell == 1, imgcell) | numpy.ma.masked_where |
import numpy as np
import cvxpy as cp
import numba
from imhist import imhist
def imhblpce(image):
[h, w] = image.shape
hist_image = imhist(image)
PMFx = hist_image / (h*w)
# CDFx = np.cumsum(PMFx)
r = (PMFx>0) * np.arange(1, 257)
r = r[r>0]
r_inv = np.where(PMFx==0, PMFx, np.ones_like(PMFx))
r_inv = np.where(PMFx==0, r_inv, np.cumsum(r_inv)).astype(np.int)
# K = len(r)
N = len(r)
# making W
#sigma
sigma = 20
# Creating Q(W, P)
W = _Creating_W(r, sigma)
P = _Creatng_P(PMFx, sigma, N)
# Q is the H in the quadprog equation : minimum( 0.5 * y'*H*y )
Q = P * W
y = _solve_quadratic_problem(Q, N)
# x = D\y
# D = np.diag(np.ones((N-1))) + np.diag(-np.ones((N-2)),k=-1)
D_inv = np.tril(np.ones((N-1, N-1)), k=0)
x = np.round(np.matmul(D_inv, y))
x = np.where(x<=256, x, 256*np.ones_like(x))
x = np.where(x>=1, x, np.ones_like(x))
x =_padzero(x-1).astype(np.uint8)
img_out = _map_image(image, r_inv, x)
# img_out = _map_image(image, r, x)
return img_out
@numba.njit()
def _map_image(image, r_inv, x):
output = image.copy().reshape(-1)
for i in range(output.size):
pixel_intensity = output[i]
output[i] = x[r_inv[pixel_intensity]-1]
return output.copy().reshape((image.shape))
# def _map_image(image, r, x):
# img_out = image.copy()
# N = len(r)
# for i in range(N):
# indx = N-i-1
# img_out[np.where(image==r[indx]-1)] = x[indx]
# return img_out
def _padzero(arr):
padded_arr = np.zeros((arr.size+1), dtype=arr.dtype)
padded_arr[1:] = arr.copy().reshape(-1)
return padded_arr
def _solve_quadratic_problem(Q, N):
# 1/2 y.T Q y
# Gx ≤ h, Ax = b
N = Q.shape[0] + 1
A = np.ones((1, N-1), dtype=np.float64)
b = np.array([256.], dtype=np.float64)
lb = np.zeros((N-1), dtype=np.float64)
ub = np.ones((N-1), dtype=np.float64) * 255
y = cp.Variable(N-1)
constraints = [y >= lb, y <= ub, A @ y == b]
prob = cp.Problem(
cp.Minimize(cp.quad_form(y, Q)),
constraints=constraints
)
prob.solve()
return np.array(y.value)
def _Creating_W(r, sigma):
N = len(r)
# r = np.insert(r, 0, 0) # r is N
r =_padzero(r)
temp_1 = np.diag( np.arange(2, N+1) )
temp_2 = np.diag( np.arange(1, N) )
w_temp = np.exp(-(r[temp_1]-r[temp_2])/(2*sigma**2))
# w_temp[np.where(w_temp==1)] = 0
w_temp = np.where(w_temp!=1, w_temp, np.zeros_like(w_temp))
w_diag = w_temp**2
temp_1 = np.diag( np.arange(3, N+1) , -1)
temp_2 = np.diag( np.arange(2, N) , -1)
w_temp_1 = np.exp(-(r[temp_1]-r[temp_2])/(2*sigma**2))
temp_1 = np.diag( np.arange(2, N) , -1)
temp_2 = np.diag( np.arange(1, N-1) , -1)
w_temp_2 = | np.exp(-(r[temp_1]-r[temp_2])/(2*sigma**2)) | numpy.exp |
# Copyright 2017 Battelle Energy Alliance, LLC
#
# 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.
"""
Created on October 28, 2015
"""
from __future__ import division, print_function, unicode_literals, absolute_import
from PostProcessorInterfaceBaseClass import PostProcessorInterfaceBase, CheckInterfacePP
import os
import numpy as np
from scipy import interpolate
import copy
from utils import InputData, InputTypes
class dataObjectLabelFilter(PostProcessorInterfaceBase):
"""
This Post-Processor filters out the points or histories accordingly to a chosen clustering label
"""
@classmethod
def getInputSpecification(cls):
"""
Method to get a reference to a class that specifies the input data for
class cls.
@ In, cls, the class for which we are retrieving the specification
@ Out, inputSpecification, InputData.ParameterInput, class to use for
specifying input of cls.
"""
inputSpecification = super().getInputSpecification()
inputSpecification.setCheckClass(CheckInterfacePP("dataObjectLabelFilter"))
DOLFDataTypeType = InputTypes.makeEnumType("DOLFDataType", "DOLFDataTypeType", ['HistorySet','PointSet'])
inputSpecification.addSubSimple("dataType", DOLFDataTypeType)
inputSpecification.addSubSimple("label", InputTypes.StringType)
inputSpecification.addSubSimple("clusterIDs", InputTypes.IntegerListType)
#Should method be in super class?
inputSpecification.addSubSimple("method", contentType=InputTypes.StringType)
return inputSpecification
def initialize(self):
"""
Method to initialize the Interfaced Post-processor
@ In, None,
@ Out, None,
"""
PostProcessorInterfaceBase.initialize(self)
self.inputFormat = None
self.outputFormat = None
self.label = None
self.clusterIDs = []
def _handleInput(self, paramInput):
"""
Function to handle the parameter input.
@ In, paramInput, ParameterInput, the already parsed input.
@ Out, None
"""
for child in paramInput.subparts:
if child.getName() == 'dataType':
dataType = child.value
if dataType in set(['HistorySet','PointSet']):
self.inputFormat = dataType
self.outputFormat = dataType
else:
self.raiseAnError(IOError, 'dataObjectLabelFilter Interfaced Post-Processor ' + str(self.name) + ' : dataType ' + str(dataType) + ' is not recognized (available are HistorySet, PointSet)')
elif child.getName() == 'label':
self.label = child.value
elif child.getName() == 'clusterIDs':
for clusterID in child.value:
self.clusterIDs.append(clusterID)
elif child.getName() !='method':
self.raiseAnError(IOError, 'dataObjectLabelFilter Interfaced Post-Processor ' + str(self.name) + ' : XML node ' + str(child) + ' is not recognized')
def run(self,inputDic):
"""
Method to post-process the dataObjects
@ In, inputDic, list, list of dictionaries which contains the data inside the input DataObjects
@ Out, outputDic, dictionary, output dictionary to be provided to the base class
"""
if len(inputDic)>1:
self.raiseAnError(IOError, 'HistorySetSync Interfaced Post-Processor ' + str(self.name) + ' accepts only one dataObject')
else:
inputDict = inputDic[0]
outputDict = {}
outputDict['data'] ={}
outputDict['dims'] = {}
outputDict['metadata'] = copy.deepcopy(inputDict['metadata']) if 'metadata' in inputDict.keys() else {}
labelType = type(inputDict['data'][self.label][0])
if labelType != np.ndarray:
indexes = np.where(np.in1d(inputDict['data'][self.label],self.clusterIDs))[0]
for key in inputDict['data'].keys():
outputDict['data'][key] = inputDict['data'][key][indexes]
outputDict['dims'][key] = []
else:
for key in inputDict['data'].keys():
if type(inputDict['data'][key][0]) == np.ndarray:
temp = []
for cnt in range(len(inputDict['data'][self.label])):
indexes = np.where(np.in1d(inputDict['data'][self.label][cnt],self.clusterIDs))[0]
if len(indexes) > 0:
temp.append(copy.deepcopy(inputDict['data'][key][cnt][indexes]))
outputDict['data'][key] = np.asanyarray(temp)
outputDict['dims'][key] = []
else:
outputDict['data'][key] = | np.empty(0) | numpy.empty |
"""
This module provides a Jones matrix framework for radio interometric
measurement equations.
"""
import copy
import numpy.ma as ma
import numpy as np
import matplotlib.pyplot as plt
from casacore.measures import measures
from casacore.quanta import quantity
from .conversion_utils import sph2crt, crt2sph, convertBasis, \
getSph2CartTransf, getSph2CartTransfArr, \
IAU_pol_basis, shiftmat2back, IAUtoC09, \
sphmeshgrid, dc_hrz2vrt
class Jones(object):
"""This is the base class for Jones algebra. It contains the Jones matrix
itself and a basis w.r.t. which the Jones matrix is given.
The basis is such that:
self.jonesbasis=array([[r_hat], [phi_hat], [theta_hat]]).
"""
_ecef_frame = 'ITRF'
_eci_frame = 'J2000'
_topo_frame = 'STN'
def __init__(self):
pass
def op(self, jonesobjright):
"""Operate this Jones on to the Jones passed in the argument."""
self.jonesr = jonesobjright.getValue()
self.jonesrbasis_from = jonesobjright.get_basis()
self.refframe_r = jonesobjright.get_refframe()
self.iaucmp = jonesobjright.iaucmp
self.computeJonesRes()
return self
def getValue(self):
"""Return value of the Jones matrix"""
return self.jones
def get_basis(self):
"""Return basis of the Jones matrix"""
return self.jonesbasis
def get_refframe(self):
"""Return the reference frame of the Jones matrix."""
return self.refframe
def computeJonesRes(self):
pass
def sph2lud3_basis(self, jonesbasis_sph, alignment=None):
"""Convert sph basis to Ludwig3 frame with an optional rotation
alignment."""
# The jonesbasis for the antennas is taken to be the Ludwig3 def.
# with r,u,v basis expressed wrt the station frame
r_refframe = jonesbasis_sph[..., 0]
if alignment is not None:
r = np.tensordot(r_refframe, alignment, axes=([-1, 1]))
else:
r = r_refframe
(az, el) = crt2sph(r.T)
lugwig3rot = np.zeros((3, 3, len(az)))
lugwig3rot[0, 0, :] = 1.
lugwig3rot[1:, 1:, :] = np.array([[np.cos(az), np.sin(az)],
[-np.sin(az), np.cos(az)]])
lugwig3rot = np.moveaxis(lugwig3rot, -1, 0)
jonesbasis_lud3 = np.matmul(jonesbasis_sph, lugwig3rot)
# ang_u = np.rad2deg(
# np.arctan2(jonesbasis_lud3[:,1,1], jonesbasis_lud3[:,0,1]))
# print ang_u
return jonesbasis_lud3
def convert2iaucmp(self):
if not self.iaucmp:
self.jones = np.matmul(self.jones, IAUtoC09[1:, 1:])
self.iaucmp = True
class JonesChain(object):
jonesproducts = []
def __init__(self):
self.jonesproducts = []
class PJones(Jones):
"""This is a P-Jones or parallactic Jones. This has a temporal dependence
given by the epoch of observation."""
def __init__(self, obsTimespy, ITRF2stnrot, do_parallactic_rot=True):
super(PJones, self).__init__()
obsTimes_lst = []
for obsTimepy in obsTimespy:
obsTimes_lst.append(quantity(obsTimepy.isoformat()).get_value())
obsTimes_me = quantity(obsTimes_lst, 'd')
self.obsTimes = obsTimes_me.get_value()
self.obsTimeUnit = obsTimes_me.get_unit()
self.ITRF2stnrot = ITRF2stnrot
self.do_parallactic_rot = do_parallactic_rot
def computeJonesRes(self):
if type(self.obsTimes) is float:
self.computeJonesRes_overfield()
else:
self.computeJonesRes_overtime()
def computeJonesRes_overtime(self):
"""Compute and apply the P Jones matrix. The structure is:
jones[time, sphcomp, skycomp] =
Pjones[time, sphcomp, comp]*jonesr[comp, skycomp]
The Pjones matrix is computed as follows: consider a direction
vector d. Let jonesrbasis be the column concatenation of the 3
spherical basis vectors corresponding to d in the J2000 reference
frame, so
jonesrbasis = [[r_J2000],[phi_J2000],[theta_J2000]].T
where r_J2000 is along the direction d and theta, phi are the remaining
two spherical basis vectors. Let jonesbasis be the basis vectors
corresponding to the same direction d but in the STN reference frame,
so
jonesbasis = [[r_STN],[phi_STN],[theta_STN]].T
where r_STN is along the direction d and theta, phi are the remaining
two spherical basis vectors in the spherical system associated with the
STN.
The algorithm takes r_J2000 from component 0 of the jonesrbasis and
converts it to STN (i.e. finds r_STN) using casacore measures module,
along with the other 2 J2000 basis vectors. These converted vectors are
called jonesrbasis_to. With r_STN, it also computes the corresponding
jonesbasis. A vector in the cartesian J2000 ref sys converted to STN
must be equal to the same vector expressed in the cartesian STN ref sys
via a coversion from spherical, so
jonesbasis * V_STN^sph = jonesrbasis_to * V_J2000^sph
which implies that we can convert directly from spherical J2000 to the
sppherical STN like this
V_STN^sph = (jonesbasis.H * jonesrbasis_to) * V_J2000^sph
where the matrix in parentheses is the P Jones matrix.
The P Jones matrix is then applied to the operand Jones matrix.
"""
nrOfTimes = len(self.obsTimes)
pjones = np.zeros((nrOfTimes, 2, 2))
me = measures()
me.doframe(measures().position(self._ecef_frame, '0m', '0m', '0m'))
self.jonesbasis = np.zeros((nrOfTimes, 3, 3))
if self.refframe_r == self._eci_frame:
convert2irf = self._ecef_frame
jonesrbasis_from = self.jonesrbasis_from
jr_refframe = self.refframe_r
else:
convert2irf = self._eci_frame
jonesrbasis_from = np.matmul(self.ITRF2stnrot.T,
self.jonesrbasis_from)
jr_refframe = self._ecef_frame
for ti in range(0, nrOfTimes):
# Set current time in reference frame
timEpoch = me.epoch('UTC', quantity(self.obsTimes[ti],
self.obsTimeUnit))
me.doframe(timEpoch)
jonesrbasis_to = np.asmatrix(convertBasis(me, jonesrbasis_from,
jr_refframe,
convert2irf))
if convert2irf == self._ecef_frame:
jonesrbasis_to = np.matmul(self.ITRF2stnrot, jonesrbasis_to)
jonesbasisMat = getSph2CartTransf(jonesrbasis_to[:, 0])
if self.do_parallactic_rot:
pjones[ti, :, :] = jonesbasisMat[:, 1:].H \
* jonesrbasis_to[:, 1:]
else:
pjones[ti, :, :] = np.asmatrix(np.identity(2))
self.jonesbasis[ti, :, :] = jonesbasisMat
if convert2irf == self._ecef_frame:
self.refframe = 'STN' # Final Ref frame is station
else:
self.refframe = self._eci_frame
self.jones = np.matmul(pjones, self.jonesr)
self.thisjones = pjones
def computeJonesRes_overfield(self):
"""Compute the PJones over field of directions for one frequency.
"""
pjones = np.zeros(self.jonesrbasis_from.shape[0:-2]+(2, 2))
me = measures()
me.doframe(measures().position(self._ecef_frame, '0m', '0m', '0m'))
self.jonesbasis = np.zeros(self.jonesrbasis_from.shape)
if self.refframe_r == self._eci_frame:
convert2irf = self._ecef_frame
jonesrbasis_from = self.jonesrbasis_from
jr_refframe = self.refframe_r
else:
convert2irf = self._eci_frame
jonesrbasis_from = np.matmul(self.ITRF2stnrot.T,
self.jonesrbasis_from)
jr_refframe = self._ecef_frame
timEpoch = me.epoch('UTC', quantity(self.obsTimes, self.obsTimeUnit))
me.doframe(timEpoch)
for idxi in range(self.jonesrbasis_from.shape[0]):
for idxj in range(self.jonesrbasis_from.shape[1]):
jonesrbasis_to = np.asmatrix(convertBasis(
me,
jonesrbasis_from[idxi, idxj, :, :],
jr_refframe, convert2irf))
if convert2irf == self._ecef_frame:
jonesrbasis_to = np.matmul(self.ITRF2stnrot,
jonesrbasis_to)
jonesbasisMat = getSph2CartTransf(jonesrbasis_to[..., 0])
pjones[idxi, idxj, :, :] = jonesbasisMat[:, 1:].H \
* jonesrbasis_to[:, 1:]
self.jonesbasis[idxi, idxj, :, :] = jonesbasisMat
if convert2irf == self._ecef_frame:
self.refframe = 'STN' # Final Ref frame is station
else:
self.refframe = self._eci_frame
self.jones = np.matmul(pjones, self.jonesr)
self.thisjones = pjones
class DualPolFieldPointSrc(Jones):
"""This is a mock Jones point source. It does not model a real source. It's
purpose is for testing. It can be seen as a source that first transmits in
one polarization and then in another, then 2 transmissions given in the 2
columns.
It may have a spectral dimension. The src_dir should be a tuple with
(az, el, ref)."""
def __init__(self, src_dir, dualPolField=np.identity(2), iaucmp=True):
(src_az, src_el, src_ref) = src_dir
dualPolField3d = np.asmatrix(np.identity(3))
dualPolField3d[1:, 1:] = np.asmatrix(dualPolField)
if iaucmp:
jones = np.matmul(IAUtoC09, dualPolField3d)[1:, 1:]
self.iaucmp = True
else:
jones = dualPolField3d[1:, 1:]
self.iaucmp = False
self.jones = | np.asarray(jones) | numpy.asarray |
import matplotlib.pyplot as plt
import os
import subprocess
import numpy as np
from PIL import Image, ImageChops
from PIL import ImageFont
from PIL import ImageDraw
from meld_classifier.dataset import load_combined_hemisphere_data
from meld_classifier.meld_cohort import MeldCohort, MeldSubject
import matplotlib_surface_plotting.matplotlib_surface_plotting as msp
import meld_classifier.paths as paths
import nibabel as nb
def trim(im):
bg = Image.new(im.mode, im.size, im.getpixel((0,0)))
diff = ImageChops.difference(im, bg)
diff = ImageChops.add(diff, diff, 2.0, -100)
bbox = diff.getbbox()
if bbox:
return im.crop(bbox)
else:
return im
def rotate90(im):
return im.transpose(method=Image.ROTATE_270)
def plot_single_subject(data_to_plots, lesion, feature_names=None, out_filename="tmp.png"):
"""create a grid of flatmap plots for a single subject"""
# load in meshes
flat = nb.load(os.path.join(paths.BASE_PATH, "fsaverage_sym", "surf", "lh.full.patch.flat.gii"))
vertices, faces = flat.darrays[0].data, flat.darrays[1].data
cortex = MeldCohort().cortex_label
cortex_bin = np.zeros(len(vertices)).astype(bool)
cortex_bin[cortex] = 1
# round up to get the square grid size
gridsize = np.ceil(np.sqrt(len(data_to_plots))).astype(int)
ims = np.zeros((gridsize, gridsize), dtype=object)
random = np.random.choice(100000)
for k, data_to_plot in enumerate(data_to_plots):
msp.plot_surf(
vertices,
faces,
data_to_plot,
flat_map=True,
base_size=10,
mask=~cortex_bin,
pvals=np.ones_like(cortex_bin),
parcel=lesion,
vmin=np.percentile(data_to_plot[cortex_bin], 1),
vmax=np.percentile(data_to_plot[cortex_bin], 99),
cmap="viridis",
colorbar=False,
filename=out_filename,
)
plt.close()
# subprocess.call(f"convert {out_filename} -trim ./tmp{random}1.png", shell=True)
# subprocess.call(f"convert ./tmp{random}1.png -rotate 90 {out_filename}", shell=True)
# os.remove(f"./tmp{random}1.png")
im = Image.open(out_filename)
im = trim(im)
im = rotate90(im)
im = im.convert("RGBA")
#fnt = ImageFont.truetype("Pillow/Tests/fonts/FreeSansBold.ttf", 25)
fnt = ImageFont.load_default()
f_name = ""
if feature_names is not None:
if k == 0:
f_name = feature_names[k]
base = np.array(im.convert("RGBA"))
else:
f_name = feature_names[k][35:-9]
draw = ImageDraw.Draw(im)
draw.text((100, 0), f_name, (255, 0, 0), font=fnt)
arr_im = np.array(im.convert("RGBA"))
s0 = np.min([base.shape[0], arr_im.shape[0]])
s1 = np.min([base.shape[1], arr_im.shape[1]])
base[:s0, :s1, :3] = arr_im[:s0, :s1, :3]
# make transparent white
# cropped[cropped[:,:,3]==0]=255
base = base[:, :, :3]
ims[k // gridsize, k % gridsize] = base.copy()
rows = np.zeros(1 + k // gridsize, dtype=object)
for j in | np.arange(1 + k // gridsize) | numpy.arange |
# -*- coding: utf-8 -*-
from __future__ import print_function
import importlib
import json
import os
import random
import re
import sys
import tempfile
import h5py
import numpy
from random_words import RandomWords, LoremIpsum
rw = RandomWords()
li = LoremIpsum()
from . import TEST_DATA_PATH, Py23FixTestCase, _random_integer, _random_float, _random_integers, _random_floats
from ..core import _str, _xrange, _decode
from ..schema import base
EMDB_SFF_VERSION = u'0.8.0.dev1'
adapter_name = 'sfftkrw.schema.adapter_v{schema_version}'.format(
schema_version=EMDB_SFF_VERSION.replace('.', '_')
)
adapter = importlib.import_module(adapter_name)
# dynamically import the latest schema generateDS API
emdb_sff_name = 'sfftkrw.schema.v{schema_version}'.format(
schema_version=EMDB_SFF_VERSION.replace('.', '_')
)
emdb_sff = importlib.import_module(emdb_sff_name)
class TestSFFRGBA(Py23FixTestCase):
def setUp(self):
self.red = random.random()
self.green = random.random()
self.blue = random.random()
self.alpha = random.random()
def test_default(self):
"""Test default colour"""
colour = adapter.SFFRGBA()
colour.red = self.red
colour.green = self.green
colour.blue = self.blue
self.assertEqual(colour.red, self.red)
self.assertEqual(colour.green, self.green)
self.assertEqual(colour.blue, self.blue)
self.assertEqual(colour.alpha, 1.0)
def test_kwarg_colour(self):
"""Test colour using kwargs"""
colour = adapter.SFFRGBA(
red=self.red,
green=self.green,
blue=self.blue,
alpha=self.alpha
)
self.assertEqual(colour.red, self.red)
self.assertEqual(colour.green, self.green)
self.assertEqual(colour.blue, self.blue)
self.assertEqual(colour.alpha, self.alpha)
def test_get_value(self):
"""Test colour.value"""
colour = adapter.SFFRGBA(
red=self.red,
green=self.green,
blue=self.blue,
alpha=self.alpha
)
red, green, blue, alpha = colour.value
self.assertEqual(colour.red, red)
self.assertEqual(colour.green, green)
self.assertEqual(colour.blue, blue)
self.assertEqual(colour.alpha, alpha)
def test_set_value(self):
"""Test colour.value = rgb(a)"""
# rgb
colour = adapter.SFFRGBA()
colour.value = self.red, self.green, self.blue
self.assertEqual(colour.red, self.red)
self.assertEqual(colour.green, self.green)
self.assertEqual(colour.blue, self.blue)
# rgba
colour.value = self.red, self.green, self.blue, self.alpha
self.assertEqual(colour.red, self.red)
self.assertEqual(colour.green, self.green)
self.assertEqual(colour.blue, self.blue)
self.assertEqual(colour.alpha, self.alpha)
def test_as_hff(self):
"""Test convert to HDF5 group"""
colour = adapter.SFFRGBA(
red=self.red,
green=self.green,
blue=self.blue,
alpha=self.alpha
)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u"container")
group = colour.as_hff(group)
self.assertIn(u"colour", group)
self.assertCountEqual(group[u'colour'][()], colour.value)
def test_from_hff(self):
"""Test create from HDF5 group"""
colour = adapter.SFFRGBA(
red=self.red,
green=self.green,
blue=self.blue,
alpha=self.alpha
)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u"container")
group = colour.as_hff(group)
self.assertIn(u"colour", group)
self.assertCountEqual(group[u'colour'][()], colour.value)
colour2 = adapter.SFFRGBA.from_hff(h[u'container'])
self.assertCountEqual(colour.value, colour2.value)
def test_native_random_colour(self):
"""Test that using a kwarg random_colour will set random colours"""
colour = adapter.SFFRGBA(random_colour=True)
self.assertTrue(0 <= colour.red <= 1)
self.assertTrue(0 <= colour.green <= 1)
self.assertTrue(0 <= colour.blue <= 1)
self.assertTrue(0 <= colour.alpha <= 1)
def test_validation(self):
"""Test that validation works"""
c = adapter.SFFRGBA(random_colour=True)
self.assertTrue(c._is_valid())
c = adapter.SFFRGBA()
self.assertFalse(c._is_valid())
def test_as_json(self):
"""Test export to JSON"""
# empty
c = adapter.SFFRGBA()
with self.assertRaisesRegex(base.SFFValueError, r".*validation.*"):
c.export(sys.stderr)
# populated
c = adapter.SFFRGBA(random_colour=True)
c_json = c.as_json()
self.assertEqual(c_json, c.value)
def test_from_json(self):
"""Test import from JSON"""
c_json = (0.8000087483646712, 0.017170600210644427, 0.5992636068532492, 1.0)
c = adapter.SFFRGBA.from_json(c_json)
self.assertEqual(c.value, c_json)
class TestSFFExternalReference(Py23FixTestCase):
def setUp(self):
self.i = _random_integer()
self.r = rw.random_word()
self.u = rw.random_word()
self.a = rw.random_word()
self.l = u" ".join(rw.random_words(count=3))
self.d = li.get_sentence()
def tearDown(self):
adapter.SFFExternalReference.reset_id()
def test_default(self):
"""Test default settings"""
e = adapter.SFFExternalReference(
resource=self.r,
url=self.u,
accession=self.a,
label=self.l,
description=self.d
)
self.assertEqual(e.id, 0)
self.assertEqual(e.resource, self.r)
self.assertEqual(e.url, self.u)
self.assertEqual(e.accession, self.a)
self.assertEqual(e.label, self.l)
self.assertEqual(e.description, self.d)
self.assertEqual(
_str(e),
u"""SFFExternalReference(id={}, resource="{}", url="{}", accession="{}", label="{}", description="{}")""".format(
0, self.r, self.u, self.a, self.l, self.d
)
)
def test_from_gds_type(self):
"""Test that we can instantiate from gds_type"""
_e = emdb_sff.external_reference_type(
id=self.i,
resource=self.r,
url=self.u,
accession=self.a,
label=self.l,
description=self.d,
)
e = adapter.SFFExternalReference.from_gds_type(_e)
self.assertEqual(e.id, self.i)
self.assertEqual(e.resource, self.r)
self.assertEqual(e.url, self.u)
self.assertEqual(e.accession, self.a)
self.assertEqual(e.label, self.l)
self.assertEqual(e.description, self.d)
self.assertEqual(
_str(e),
u"""SFFExternalReference(id={}, resource="{}", url="{}", accession="{}", label="{}", description="{}")""".format(
self.i, self.r, self.u, self.a, self.l, self.d
)
)
def test_as_json(self):
"""Test that we can output as JSON"""
e = adapter.SFFExternalReference()
self.assertEqual(e.as_json(), {
u"id": e.id,
u"resource": None,
u"url": None,
u"accession": None,
u"label": None,
u"description": None,
})
e = adapter.SFFExternalReference(
resource=self.r,
url=self.u,
accession=self.a,
label=self.l,
description=self.d,
)
e_json = e.as_json()
self.assertEqual(e_json[u'id'], e.id)
self.assertEqual(e_json[u'resource'], e.resource)
self.assertEqual(e_json[u'url'], e.url)
self.assertEqual(e_json[u'accession'], e.accession)
self.assertEqual(e_json[u'label'], e.label)
self.assertEqual(e_json[u'description'], e.description)
# missing mandatory
e = adapter.SFFExternalReference(
# resource=self.r,
# url=self.u,
# accession=self.a,
label=self.l,
description=self.d,
)
with self.assertRaisesRegex(base.SFFValueError, r".*validation.*"):
e.export(sys.stderr)
# missing non-mandatory
e = adapter.SFFExternalReference(
resource=self.r,
url=self.u,
accession=self.a,
# label=self.l,
# description=self.d,
)
self.assertEqual(e_json[u'resource'], e.resource)
self.assertEqual(e_json[u'url'], e.url)
self.assertEqual(e_json[u'accession'], e.accession)
def test_from_json(self):
"""Test that we can recreate from JSON"""
e_json = {'id': 0, 'resource': 'symptom', 'url': 'thin', 'accession': 'definitions',
'label': 'chairpersons swabs pools',
'description': 'Malesuada facilisinam elitduis mus dis facer, primis est pellentesque integer dapibus '
'semper semvestibulum curae lacusnulla.'}
e = adapter.SFFExternalReference.from_json(e_json)
self.assertEqual(e_json[u'id'], e.id)
self.assertEqual(e_json[u'resource'], e.resource)
self.assertEqual(e_json[u'url'], e.url)
self.assertEqual(e_json[u'accession'], e.accession)
self.assertEqual(e_json[u'label'], e.label)
self.assertEqual(e_json[u'description'], e.description)
# missing mandatory
e_json = {'id': 0, 'url': 'thin', 'accession': 'definitions',
'label': 'chairpersons swabs pools',
'description': 'Malesuada facilisinam elitduis mus dis facer, primis est pellentesque integer dapibus '
'semper semvestibulum curae lacusnulla.'}
adapter.SFFExternalReference.from_json(e_json)
# missing non-mandatory
e_json = {'resource': 'symptom', 'url': 'thin', 'accession': 'definitions',
'label': 'chairpersons swabs pools'}
e = adapter.SFFExternalReference.from_json(e_json)
self.assertIsNone(e.id)
self.assertEqual(e_json[u'resource'], e.resource)
self.assertEqual(e_json[u'url'], e.url)
self.assertEqual(e_json[u'accession'], e.accession)
self.assertEqual(e_json[u'label'], e.label)
self.assertIsNone(e.description)
def test_hff(self):
"""Interconversion to HDF5"""
# empty
e = adapter.SFFExternalReference()
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = e.as_hff(group)
self.assertIn(u'{}'.format(e.id), group)
with h5py.File(self.test_hdf5_fn, u'r') as h:
for group in h[u'container'].values():
e2 = adapter.SFFExternalReference.from_hff(group)
self.assertEqual(e, e2)
self.assertIsInstance(e2.id, int)
# empty with id=None
e = adapter.SFFExternalReference(new_obj=False)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = e.as_hff(group)
self.assertIn(u'{}'.format(e.id), group)
with h5py.File(self.test_hdf5_fn, u'r') as h:
for group in h[u'container'].values():
e2 = adapter.SFFExternalReference.from_hff(group)
self.assertEqual(e, e2)
# pop'd
e = adapter.SFFExternalReference(
resource=self.r,
url=self.u,
accession=self.a,
label=self.l,
description=self.d,
)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = e.as_hff(group)
group_name = u'{}'.format(e.id)
self.assertIn(group_name, group)
self.assertIn(group_name + u'/resource', group)
self.assertIn(group_name + u'/url', group)
self.assertIn(group_name + u'/accession', group)
self.assertIn(group_name + u'/label', group)
self.assertIn(group_name + u'/description', group)
self.assertEqual(group[group_name + u'/id'][()], e.id)
self.assertEqual(_decode(group[group_name + u'/resource'][()], 'utf-8'), e.resource)
self.assertEqual(_decode(group[group_name + u'/url'][()], 'utf-8'), e.url)
self.assertEqual(_decode(group[group_name + u'/accession'][()], 'utf-8'), e.accession)
self.assertEqual(_decode(group[group_name + u'/label'][()], 'utf-8'), e.label)
self.assertEqual(_decode(group[group_name + u'/description'][()], 'utf-8'), e.description)
with h5py.File(self.test_hdf5_fn, u'r') as h:
for group in h[u'container'].values():
e2 = adapter.SFFExternalReference.from_hff(group)
self.assertEqual(e, e2)
# missing non-mandatory
e = adapter.SFFExternalReference(
resource=self.r,
url=self.u,
accession=self.a,
)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = e.as_hff(group)
group_name = u'{}'.format(e.id)
self.assertIn(group_name, group)
self.assertIn(group_name + u'/resource', group)
self.assertIn(group_name + u'/url', group)
self.assertIn(group_name + u'/accession', group)
self.assertNotIn(group_name + u'/label', group)
self.assertNotIn(group_name + u'/description', group)
self.assertEqual(group[group_name + u'/id'][()], e.id)
self.assertEqual(_decode(group[group_name + u'/resource'][()], 'utf-8'), e.resource)
self.assertEqual(_decode(group[group_name + u'/url'][()], 'utf-8'), e.url)
self.assertEqual(_decode(group[group_name + u'/accession'][()], 'utf-8'), e.accession)
with h5py.File(self.test_hdf5_fn, u'r') as h:
for group in h[u'container'].values():
e2 = adapter.SFFExternalReference.from_hff(group)
self.assertEqual(e, e2)
class TestSFFExternalReferenceList(Py23FixTestCase):
def setUp(self):
self._no_items = _random_integer(start=2, stop=10)
self.ii = list(_xrange(self._no_items))
self.rr = [rw.random_word() for _ in _xrange(self._no_items)]
self.uu = [rw.random_word() for _ in _xrange(self._no_items)]
self.aa = [rw.random_word() for _ in _xrange(self._no_items)]
self.ll = [" ".join(rw.random_words(count=3)) for _ in _xrange(self._no_items)]
self.dd = [li.get_sentence() for _ in _xrange(self._no_items)]
def tearDown(self):
adapter.SFFExternalReference.reset_id()
def test_default(self):
"""Test default settings"""
ee = [adapter.SFFExternalReference(
resource=self.rr[i],
url=self.uu[i],
accession=self.aa[i],
label=self.ll[i],
description=self.dd[i]
) for i in _xrange(self._no_items)]
E = adapter.SFFExternalReferenceList()
[E.append(e) for e in ee]
# str
self.assertRegex(
_str(E),
r"""SFFExternalReferenceList\(\[.*\]\)"""
)
# length
self.assertEqual(len(E), self._no_items)
# get
e = E[self._no_items - 1]
self.assertIsInstance(e, adapter.SFFExternalReference)
self.assertEqual(e.id, self._no_items - 1)
self.assertEqual(e.resource, self.rr[self._no_items - 1])
self.assertEqual(e.url, self.uu[self._no_items - 1])
self.assertEqual(e.accession, self.aa[self._no_items - 1])
self.assertEqual(e.label, self.ll[self._no_items - 1])
self.assertEqual(e.description, self.dd[self._no_items - 1])
# get_ids
e_ids = E.get_ids()
self.assertEqual(len(e_ids), self._no_items)
# get_by_ids
e_id = random.choice(list(e_ids))
e = E.get_by_id(e_id)
self.assertIsInstance(e, adapter.SFFExternalReference)
self.assertEqual(e.id, e_id)
self.assertEqual(e.resource, self.rr[e_id])
self.assertEqual(e.url, self.uu[e_id])
self.assertEqual(e.accession, self.aa[e_id])
self.assertEqual(e.label, self.ll[e_id])
self.assertEqual(e.description, self.dd[e_id])
def test_create_from_gds_type(self):
"""Test that we can create from gds_type"""
_ee = [emdb_sff.external_reference_type(
id=self.ii[i],
resource=self.rr[i],
url=self.uu[i],
accession=self.aa[i],
label=self.ll[i],
description=self.dd[i]
) for i in _xrange(self._no_items)]
_E = emdb_sff.external_referencesType()
_E.set_ref(_ee)
E = adapter.SFFExternalReferenceList.from_gds_type(_E)
# str
self.assertRegex(
_str(E),
r"""SFFExternalReferenceList\(\[.*\]\)"""
)
# length
self.assertEqual(len(E), self._no_items)
# get
e = E[self._no_items - 1]
self.assertIsInstance(e, adapter.SFFExternalReference)
self.assertEqual(e.id, self._no_items - 1)
self.assertEqual(e.resource, self.rr[self._no_items - 1])
self.assertEqual(e.url, self.uu[self._no_items - 1])
self.assertEqual(e.accession, self.aa[self._no_items - 1])
self.assertEqual(e.label, self.ll[self._no_items - 1])
self.assertEqual(e.description, self.dd[self._no_items - 1])
# get_ids
e_ids = E.get_ids()
self.assertEqual(len(e_ids), self._no_items)
# get_by_ids
e_id = random.choice(list(e_ids))
e = E.get_by_id(e_id)
self.assertIsInstance(e, adapter.SFFExternalReference)
self.assertEqual(e.id, e_id)
self.assertEqual(e.resource, self.rr[e_id])
self.assertEqual(e.url, self.uu[e_id])
self.assertEqual(e.accession, self.aa[e_id])
self.assertEqual(e.label, self.ll[e_id])
self.assertEqual(e.description, self.dd[e_id])
def test_as_json(self):
"""Test that we can export to JSON"""
ee = adapter.SFFExternalReferenceList()
self.assertEqual(ee.as_json(), [])
ee = [adapter.SFFExternalReference(
resource=self.rr[i],
url=self.uu[i],
accession=self.aa[i],
label=self.ll[i],
description=self.dd[i]
) for i in _xrange(self._no_items)]
E = adapter.SFFExternalReferenceList()
[E.append(e) for e in ee]
E_json = E.as_json()
# _print(E_json)
for i in _xrange(self._no_items):
self.assertEqual(E[i].id, E_json[i][u'id'])
self.assertEqual(E[i].resource, E_json[i][u'resource'])
self.assertEqual(E[i].url, E_json[i][u'url'])
self.assertEqual(E[i].accession, E_json[i][u'accession'])
self.assertEqual(E[i].label, E_json[i][u'label'])
self.assertEqual(E[i].description, E_json[i][u'description'])
# empty
E = adapter.SFFExternalReferenceList()
E_json = E.as_json()
self.assertEqual(len(E), len(E_json))
def test_from_json(self):
"""Test that we can import from JSON"""
E_json = [{'id': 0, 'resource': 'projectiles', 'url': 'blast', 'accession': 'injector',
'label': 'bricks breaches crawl',
'description': 'Est facilisicurabitur morbi dapibus volutpat, vestibulumnulla consecteturpraesent velit sempermorbi diaminteger taciti risusdonec accusam.'},
{'id': 1, 'resource': 'signals', 'url': 'wines', 'accession': 'experience',
'label': 'alibi defaults showers',
'description': 'Auctor habitasse amet temporsuspendisse, integer hendrerit nullasuspendisse.'},
{'id': 2, 'resource': 'openings', 'url': 'pack', 'accession': 'augmentations',
'label': 'outing rings tilling',
'description': 'Liberoduis esse nobis semvestibulum bibendumin non, sagittis eget eum massapellentesque eratproin nonummy massaphasellus.'},
{'id': 3, 'resource': 'blaze', 'url': 'contract', 'accession': 'diagrams',
'label': 'sewers weddings telecommunications',
'description': 'Ipsum no luctus ultricies enimsed antesuspendisse.'},
{'id': 4, 'resource': 'terms', 'url': 'blackboard', 'accession': 'nothing',
'label': 'depot trades strikers', 'description': 'Elitr hendrerit tortorvestibulum exerci.'},
{'id': 5, 'resource': 'carriage', 'url': 'screens', 'accession': 'apprehension',
'label': 'signalers hunk wagon', 'description': 'Consequatduis muspellentesque.'},
{'id': 6, 'resource': 'lot', 'url': 'gums', 'accession': 'rim', 'label': 'chatter north clearances',
'description': 'Nostra felis.'},
{'id': 7, 'resource': 'outlet', 'url': 'actions', 'accession': 'twists',
'label': 'compromises additives mirrors',
'description': 'Diaminteger phasellus mi sollicitudin laoreetphasellus possim, himenaeos semvestibulum egestasmauris clita elitnunc suscipit pulvinar.'},
{'id': 8, 'resource': 'shears', 'url': 'user', 'accession': 'view', 'label': 'cable diagram churns',
'description': 'Dolor laoreet adipiscing takimata neque dignissim velit enimaliquam, lobortisetiam mazim nunccurabitur aliquip praesent blandit.'},
{'id': 9, 'resource': 'jurisdiction', 'url': 'plug', 'accession': 'calibrations',
'label': 'oscillation baby males', 'description': 'Iusto aliquam quod orci, aaenean justo luctus.'}]
E = adapter.SFFExternalReferenceList.from_json(E_json)
for i, extref in enumerate(E_json):
self.assertEqual(E[i].id, extref[u'id'])
self.assertEqual(E[i].resource, extref[u'resource'])
self.assertEqual(E[i].url, extref[u'url'])
self.assertEqual(E[i].accession, extref[u'accession'])
self.assertEqual(E[i].label, extref[u'label'])
self.assertEqual(E[i].description, extref[u'description'])
def test_hff(self):
"""Interconvert to HDF5"""
# empty
ee = adapter.SFFExternalReferenceList()
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = ee.as_hff(group)
self.assertIn(u'external_references', group)
self.assertEqual(len(ee), 0)
self.assertEqual(len(ee), len(group[u'external_references']))
with h5py.File(self.test_hdf5_fn, u'r') as h:
ee2 = adapter.SFFExternalReferenceList.from_hff(h[u'container'])
self.assertEqual(ee, ee2)
# pop'd but empty extrefs
ee = adapter.SFFExternalReferenceList()
e = adapter.SFFExternalReference()
ee.append(e)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = ee.as_hff(group)
with h5py.File(self.test_hdf5_fn, u'r') as h:
ee2 = adapter.SFFExternalReferenceList.from_hff(h[u'container'])
self.assertEqual(ee, ee2)
# pop'd
ee = [adapter.SFFExternalReference(
resource=self.rr[i],
url=self.uu[i],
accession=self.aa[i],
label=self.ll[i],
description=self.dd[i]
) for i in _xrange(self._no_items)]
E = adapter.SFFExternalReferenceList()
[E.append(e) for e in ee]
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = E.as_hff(group)
self.assertIn(u'external_references', group)
self.assertTrue(len(ee) > 0)
self.assertEqual(len(ee), len(group[u'external_references']))
for er in E:
self.assertEqual(er,
adapter.SFFExternalReference.from_hff(group[u'external_references/{}'.format(er.id)]))
with h5py.File(self.test_hdf5_fn, u'r') as h:
ee2 = adapter.SFFExternalReferenceList.from_hff(h[u'container'])
class TestSFFGlobalExternalReferenceList(Py23FixTestCase):
"""Test the SFFGlobalExternalReferenceList class"""
def setUp(self):
self._no_items = _random_integer(start=2, stop=10)
self.ii = list(_xrange(self._no_items))
self.rr = [rw.random_word() for _ in _xrange(self._no_items)]
self.uu = [rw.random_word() for _ in _xrange(self._no_items)]
self.aa = [rw.random_word() for _ in _xrange(self._no_items)]
self.ll = [" ".join(rw.random_words(count=3)) for _ in _xrange(self._no_items)]
self.dd = [li.get_sentence() for _ in _xrange(self._no_items)]
def tearDown(self):
adapter.SFFExternalReference.reset_id()
def test_default(self):
"""Test default settings"""
ee = [adapter.SFFExternalReference(
resource=self.rr[i],
url=self.uu[i],
accession=self.aa[i],
label=self.ll[i],
description=self.dd[i]
) for i in _xrange(self._no_items)]
G = adapter.SFFGlobalExternalReferenceList()
[G.append(e) for e in ee]
# str
self.assertRegex(
_str(G),
r"""SFFGlobalExternalReferenceList\(\[.*\]\)"""
)
# length
self.assertEqual(len(G), self._no_items)
# get
e = G[self._no_items - 1]
self.assertIsInstance(e, adapter.SFFExternalReference)
self.assertEqual(e.id, self._no_items - 1)
self.assertEqual(e.resource, self.rr[self._no_items - 1])
self.assertEqual(e.url, self.uu[self._no_items - 1])
self.assertEqual(e.accession, self.aa[self._no_items - 1])
self.assertEqual(e.label, self.ll[self._no_items - 1])
self.assertEqual(e.description, self.dd[self._no_items - 1])
# get_ids
e_ids = G.get_ids()
self.assertEqual(len(e_ids), self._no_items)
# get_by_ids
e_id = random.choice(list(e_ids))
e = G.get_by_id(e_id)
self.assertIsInstance(e, adapter.SFFExternalReference)
self.assertEqual(e.id, e_id)
self.assertEqual(e.resource, self.rr[e_id])
self.assertEqual(e.url, self.uu[e_id])
self.assertEqual(e.accession, self.aa[e_id])
self.assertEqual(e.label, self.ll[e_id])
self.assertEqual(e.description, self.dd[e_id])
def test_create_from_gds_type(self):
"""Test that we can create from gds_type"""
_ee = [emdb_sff.external_reference_type(
id=self.ii[i],
resource=self.rr[i],
url=self.uu[i],
accession=self.aa[i],
label=self.ll[i],
description=self.dd[i]
) for i in _xrange(self._no_items)]
_G = emdb_sff.global_external_referencesType()
_G.set_ref(_ee)
G = adapter.SFFGlobalExternalReferenceList.from_gds_type(_G)
# str
self.assertRegex(
_str(G),
r"""SFFGlobalExternalReferenceList\(\[.*\]\)"""
)
# length
self.assertEqual(len(G), self._no_items)
# get
e = G[self._no_items - 1]
self.assertIsInstance(e, adapter.SFFExternalReference)
self.assertEqual(e.id, self._no_items - 1)
self.assertEqual(e.resource, self.rr[self._no_items - 1])
self.assertEqual(e.url, self.uu[self._no_items - 1])
self.assertEqual(e.accession, self.aa[self._no_items - 1])
self.assertEqual(e.label, self.ll[self._no_items - 1])
self.assertEqual(e.description, self.dd[self._no_items - 1])
# get_ids
e_ids = G.get_ids()
self.assertEqual(len(e_ids), self._no_items)
# get_by_ids
e_id = random.choice(list(e_ids))
e = G.get_by_id(e_id)
self.assertIsInstance(e, adapter.SFFExternalReference)
self.assertEqual(e.id, e_id)
self.assertEqual(e.resource, self.rr[e_id])
self.assertEqual(e.url, self.uu[e_id])
self.assertEqual(e.accession, self.aa[e_id])
self.assertEqual(e.label, self.ll[e_id])
self.assertEqual(e.description, self.dd[e_id])
def test_as_json(self):
"""Test that we can export to JSON"""
ge = adapter.SFFGlobalExternalReferenceList()
self.assertEqual(ge.as_json(), [])
ge = [adapter.SFFExternalReference(
resource=self.rr[i],
url=self.uu[i],
accession=self.aa[i],
label=self.ll[i],
description=self.dd[i]
) for i in _xrange(self._no_items)]
G = adapter.SFFGlobalExternalReferenceList()
[G.append(g) for g in ge]
G_json = G.as_json()
for i in _xrange(self._no_items):
self.assertEqual(G[i].id, G_json[i][u'id'])
self.assertEqual(G[i].resource, G_json[i][u'resource'])
self.assertEqual(G[i].url, G_json[i][u'url'])
self.assertEqual(G[i].accession, G_json[i][u'accession'])
self.assertEqual(G[i].label, G_json[i][u'label'])
self.assertEqual(G[i].description, G_json[i][u'description'])
# empty
G = adapter.SFFGlobalExternalReferenceList()
G_json = G.as_json()
self.assertEqual(len(G), len(G_json))
def test_from_json(self):
"""Test that we can import from JSON"""
G_json = [{'id': 0, 'resource': 'projectiles', 'url': 'blast', 'accession': 'injector',
'label': 'bricks breaches crawl',
'description': 'Est facilisicurabitur morbi dapibus volutpat, vestibulumnulla consecteturpraesent velit sempermorbi diaminteger taciti risusdonec accusam.'},
{'id': 1, 'resource': 'signals', 'url': 'wines', 'accession': 'experience',
'label': 'alibi defaults showers',
'description': 'Auctor habitasse amet temporsuspendisse, integer hendrerit nullasuspendisse.'},
{'id': 2, 'resource': 'openings', 'url': 'pack', 'accession': 'augmentations',
'label': 'outing rings tilling',
'description': 'Liberoduis esse nobis semvestibulum bibendumin non, sagittis eget eum massapellentesque eratproin nonummy massaphasellus.'},
{'id': 3, 'resource': 'blaze', 'url': 'contract', 'accession': 'diagrams',
'label': 'sewers weddings telecommunications',
'description': 'Ipsum no luctus ultricies enimsed antesuspendisse.'},
{'id': 4, 'resource': 'terms', 'url': 'blackboard', 'accession': 'nothing',
'label': 'depot trades strikers', 'description': 'Elitr hendrerit tortorvestibulum exerci.'},
{'id': 5, 'resource': 'carriage', 'url': 'screens', 'accession': 'apprehension',
'label': 'signalers hunk wagon', 'description': 'Consequatduis muspellentesque.'},
{'id': 6, 'resource': 'lot', 'url': 'gums', 'accession': 'rim', 'label': 'chatter north clearances',
'description': 'Nostra felis.'},
{'id': 7, 'resource': 'outlet', 'url': 'actions', 'accession': 'twists',
'label': 'compromises additives mirrors',
'description': 'Diaminteger phasellus mi sollicitudin laoreetphasellus possim, himenaeos semvestibulum egestasmauris clita elitnunc suscipit pulvinar.'},
{'id': 8, 'resource': 'shears', 'url': 'user', 'accession': 'view', 'label': 'cable diagram churns',
'description': 'Dolor laoreet adipiscing takimata neque dignissim velit enimaliquam, lobortisetiam mazim nunccurabitur aliquip praesent blandit.'},
{'id': 9, 'resource': 'jurisdiction', 'url': 'plug', 'accession': 'calibrations',
'label': 'oscillation baby males', 'description': 'Iusto aliquam quod orci, aaenean justo luctus.'}]
G = adapter.SFFGlobalExternalReferenceList.from_json(G_json)
for i, extref in enumerate(G_json):
self.assertEqual(G[i].id, extref[u'id'])
self.assertEqual(G[i].resource, extref[u'resource'])
self.assertEqual(G[i].url, extref[u'url'])
self.assertEqual(G[i].accession, extref[u'accession'])
self.assertEqual(G[i].label, extref[u'label'])
self.assertEqual(G[i].description, extref[u'description'])
def test_hff(self):
"""Interconvert to HDF5"""
# empty
G = adapter.SFFGlobalExternalReferenceList()
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = G.as_hff(group)
self.assertIn(u'global_external_references', group)
self.assertEqual(len(G), 0)
self.assertEqual(len(G), len(group[u'global_external_references']))
with h5py.File(self.test_hdf5_fn, u'r') as h:
G2 = adapter.SFFGlobalExternalReferenceList.from_hff(h[u'container'])
self.assertEqual(G, G2)
# pop'd
G = adapter.SFFGlobalExternalReferenceList()
[G.append(adapter.SFFExternalReference(
resource=self.rr[i],
url=self.uu[i],
accession=self.aa[i],
label=self.ll[i],
description=self.dd[i]
)) for i in _xrange(self._no_items)]
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = G.as_hff(group)
# self.stderrh(h)
self.assertIn(u'global_external_references', group)
self.assertTrue(len(G) > 0)
self.assertEqual(len(G), len(group[u'global_external_references']))
for er in G:
self.assertEqual(er, adapter.SFFExternalReference.from_hff(
group[u'global_external_references/{}'.format(er.id)]))
with h5py.File(self.test_hdf5_fn, u'r') as h:
G2 = adapter.SFFGlobalExternalReferenceList.from_hff(h[u'container'])
self.assertEqual(G, G2)
class TestSFFBiologicalAnnotation(Py23FixTestCase):
def setUp(self):
self.name = " ".join(rw.random_words(count=3))
self.description = li.get_sentence()
self._no_items = _random_integer(start=2, stop=10)
self.ii = list(_xrange(self._no_items))
self.rr = [rw.random_word() for _ in _xrange(self._no_items)]
self.uu = [rw.random_word() for _ in _xrange(self._no_items)]
self.aa = [rw.random_word() for _ in _xrange(self._no_items)]
self.ll = [" ".join(rw.random_words(count=3)) for _ in _xrange(self._no_items)]
self.dd = [li.get_sentence() for _ in _xrange(self._no_items)]
self.ee = [adapter.SFFExternalReference(
resource=self.rr[i],
url=self.uu[i],
accession=self.aa[i],
label=self.ll[i],
description=self.dd[i]
) for i in _xrange(self._no_items)]
self._ee = [emdb_sff.external_reference_type(
resource=self.rr[i],
url=self.uu[i],
accession=self.aa[i],
label=self.ll[i],
description=self.dd[i]
) for i in _xrange(self._no_items)]
E = adapter.SFFExternalReferenceList()
[E.append(e) for e in self.ee]
_E = emdb_sff.external_referencesType()
_E.set_ref(self._ee)
self.external_references = E
self._external_references = _E
self.no = _random_integer()
def test_default(self):
"""Test default settings"""
b = adapter.SFFBiologicalAnnotation(
name=self.name,
description=self.description,
external_references=self.external_references,
number_of_instances=self.no,
)
self.assertRegex(
_str(b),
r"""SFFBiologicalAnnotation\(""" \
r"""name="{}", description="{}", """ \
r"""number_of_instances={}, """ \
r"""external_references=SFFExternalReferenceList\(\[.*\]\)\)""".format(
self.name,
self.description,
self.no
)
)
self.assertEqual(b.name, self.name)
self.assertEqual(b.description, self.description)
self.assertEqual(b.number_of_instances, self.no)
self.assertEqual(b.external_references, self.external_references)
def test_create_from_gds_type(self):
"""Test that we can create from a gds_type"""
_b = emdb_sff.biological_annotationType(
name=self.name,
description=self.description,
number_of_instances=self.no,
external_references=self._external_references
)
b = adapter.SFFBiologicalAnnotation.from_gds_type(_b)
self.assertRegex(
_str(b),
r"""SFFBiologicalAnnotation\(""" \
r"""name="{}", description="{}", """ \
r"""number_of_instances={}, """ \
r"""external_references=SFFExternalReferenceList\(\[.*\]\)\)""".format(
self.name,
self.description,
self.no
)
)
self.assertEqual(b.name, self.name)
self.assertEqual(b.description, self.description)
self.assertEqual(b.number_of_instances, self.no)
self.assertEqual(b.external_references, self.external_references)
def test_as_json(self):
"""Test conversion to and from JSON"""
# empty case
b_empty = adapter.SFFBiologicalAnnotation()
b_json = b_empty.as_json()
self.assertEqual(b_json, {
u"name": None,
u"description": None,
u"external_references": [],
u"number_of_instances": 1,
})
b2_empty = adapter.SFFBiologicalAnnotation.from_json(b_json)
self.assertEqual(b_empty, b2_empty)
# non-empty case
b_full = adapter.SFFBiologicalAnnotation()
b_full.name = ' '.join(rw.random_words(count=2))
b_full.description = li.get_sentence()
es = adapter.SFFExternalReferenceList()
no_es = _random_integer(2, 10)
for _ in _xrange(no_es):
e = adapter.SFFExternalReference()
e.resource = rw.random_word()
e.url = rw.random_word()
e.accession = rw.random_word()
e.label = ' '.join(rw.random_words(count=3))
e.description = li.get_sentence()
es.append(e)
b_full.external_references = es
b_json = b_full.as_json()
b2_full = adapter.SFFBiologicalAnnotation.from_json(b_json)
self.assertEqual(b_full, b2_full)
def test_from_json(self):
"""Test that we can import from JSON"""
b_json = {'name': 'returns agent', 'description': 'Lacus leopraesent risusdonec tempus congue.',
'external_references': [{'id': 0, 'resource': 'listing', 'url': 'antennas', 'accession': 'weddings',
'label': 'times selection deployment',
'description': 'Facilisicurabitur mi sanctus fames dignissim autem.'},
{'id': 1, 'resource': 'basis', 'url': 'leaks', 'accession': 'cups',
'label': 'yaw workloads house', 'description': 'Nequeetiam habitasse.'},
{'id': 2, 'resource': 'chance', 'url': 'theory', 'accession': 'allegation',
'label': 'maps chairwomen flashes',
'description': 'Suscipit eos pulvinar zzril doming dolores.'}]}
b_full = adapter.SFFBiologicalAnnotation.from_json(b_json)
self.assertEqual(b_full.name, b_json[u'name'])
self.assertEqual(b_full.description, b_json[u'description'])
try:
self.assertEqual(b_full.number_of_instances, b_json[u'number_of_instances'])
except KeyError:
self.assertEqual(b_full.number_of_instances, 1)
for i, extref in enumerate(b_json[u'external_references']):
self.assertEqual(b_full.external_references[i].id, extref[u'id'])
self.assertEqual(b_full.external_references[i].resource, extref[u'resource'])
self.assertEqual(b_full.external_references[i].url, extref[u'url'])
self.assertEqual(b_full.external_references[i].accession, extref[u'accession'])
self.assertEqual(b_full.external_references[i].label, extref[u'label'])
self.assertEqual(b_full.external_references[i].description, extref[u'description'])
def test_hff(self):
"""Interconvert to HDF5"""
# empty case
b_empty = adapter.SFFBiologicalAnnotation()
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = b_empty.as_hff(group)
self.assertIn(u'biological_annotation', group)
with h5py.File(self.test_hdf5_fn, u'r') as h:
b_empty2 = adapter.SFFBiologicalAnnotation.from_hff(h[u'container'])
self.assertEqual(b_empty, b_empty2)
# non-empty case
b_full = adapter.SFFBiologicalAnnotation()
b_full.name = ' '.join(rw.random_words(count=2))
b_full.description = li.get_sentence()
es = adapter.SFFExternalReferenceList()
no_es = _random_integer(2, 10)
for _ in _xrange(no_es):
e = adapter.SFFExternalReference()
e.resource = rw.random_word()
e.url = rw.random_word()
e.accession = rw.random_word()
e.label = ' '.join(rw.random_words(count=3))
e.description = li.get_sentence()
es.append(e)
b_full.external_references = es
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = b_full.as_hff(group)
self.assertIn(u'biological_annotation', group)
self.assertIn(u'name', group[u'biological_annotation'])
self.assertEqual(_decode(group[u'biological_annotation/name'][()], 'utf-8'), b_full.name)
self.assertIn(u'description', group[u'biological_annotation'])
self.assertEqual(_decode(group[u'biological_annotation/description'][()], 'utf-8'), b_full.description)
self.assertIn(u'number_of_instances', group[u'biological_annotation'])
self.assertEqual(_decode(group[u'biological_annotation/number_of_instances'][()], 'utf-8'), b_full.number_of_instances)
self.assertIn(u'external_references', group[u'biological_annotation'])
self.assertEqual(len(group[u'biological_annotation/external_references']),
len(b_full.external_references))
with h5py.File(self.test_hdf5_fn, u'r') as h:
b_full2 = adapter.SFFBiologicalAnnotation.from_hff(h[u'container'])
self.assertEqual(b_full, b_full2)
class TestSFFThreeDVolume(Py23FixTestCase):
def setUp(self):
self.lattice_id = _random_integer()
self.value = _random_integer()
self.transform_id = _random_integer()
def test_default(self):
"""Test default settings"""
v = adapter.SFFThreeDVolume(
lattice_id=self.lattice_id,
value=self.value,
transform_id=self.transform_id,
)
self.assertEqual(
_str(v),
"""SFFThreeDVolume(lattice_id={}, value={}, transform_id={})""".format(
self.lattice_id,
self.value,
self.transform_id
)
)
self.assertEqual(v.lattice_id, self.lattice_id)
self.assertEqual(v.value, self.value)
self.assertEqual(v.transform_id, self.transform_id)
def test_create_from_gds_type(self):
"""Test that we can create from a gds_type"""
_v = emdb_sff.three_d_volume_type(
lattice_id=self.lattice_id,
value=self.value,
transform_id=self.transform_id
)
v = adapter.SFFThreeDVolume.from_gds_type(_v)
self.assertEqual(
_str(v),
"""SFFThreeDVolume(lattice_id={}, value={}, transform_id={})""".format(
self.lattice_id,
self.value,
self.transform_id
)
)
self.assertEqual(v.lattice_id, self.lattice_id)
self.assertEqual(v.value, self.value)
self.assertEqual(v.transform_id, self.transform_id)
def test_json(self):
lattice_id = _random_integer(start=1)
value = _random_integer(start=1)
transform_id = _random_integer(start=0)
vol_full = adapter.SFFThreeDVolume(lattice_id=lattice_id, value=value, transform_id=transform_id)
vol_json = vol_full.as_json()
vol_full2 = adapter.SFFThreeDVolume.from_json(vol_json)
self.assertEqual(vol_full, vol_full2)
# empty
vol_empty = adapter.SFFThreeDVolume()
vol_empty_json = vol_empty.as_json()
self.assertIsNone(vol_empty_json[u'lattice_id'])
self.assertIsNone(vol_empty_json[u'value'])
vol_empty2 = adapter.SFFThreeDVolume.from_json(vol_empty_json)
self.assertEqual(vol_empty, vol_empty2)
def test_hff(self):
lattice_id = _random_integer(start=1)
value = _random_integer(start=1)
transform_id = _random_integer(start=0)
vol_full = adapter.SFFThreeDVolume(lattice_id=lattice_id, value=value, transform_id=transform_id)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = vol_full.as_hff(group)
self.assertIn(u'three_d_volume', group)
self.assertEqual(group[u'three_d_volume/lattice_id'][()], vol_full.lattice_id)
self.assertEqual(group[u'three_d_volume/value'][()], vol_full.value)
self.assertEqual(group[u'three_d_volume/transform_id'][()], vol_full.transform_id)
with h5py.File(self.test_hdf5_fn, u'r') as h:
vol_full2 = adapter.SFFThreeDVolume.from_hff(h[u'container'])
self.assertEqual(vol_full, vol_full2)
self.assertIsInstance(vol_full2.lattice_id, int)
self.assertIsInstance(vol_full2.transform_id, int)
# empty
vol_empty = adapter.SFFThreeDVolume()
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = vol_empty.as_hff(group)
self.assertIn(u'three_d_volume', group)
self.assertNotIn(u'lattice_id', group[u'three_d_volume'])
self.assertNotIn(u'value', group[u'three_d_volume'])
self.assertNotIn(u'transform_id', group[u'three_d_volume'])
with h5py.File(self.test_hdf5_fn, u'r') as h:
vol_empty2 = adapter.SFFThreeDVolume.from_hff(h[u'container'])
self.assertEqual(vol_empty, vol_empty2)
self.assertIsInstance(vol_full2.lattice_id, int)
self.assertIsInstance(vol_full2.transform_id, int)
class TestSFFVolumeStructure(Py23FixTestCase):
def setUp(self):
self.cols = _random_integer()
self.rows = _random_integer()
self.sections = _random_integer()
def test_default(self):
"""Test default settings"""
vs = adapter.SFFVolumeStructure(cols=self.cols, rows=self.rows, sections=self.sections)
self.assertRegex(_str(vs), r"SFFVolumeStructure\(cols.*rows.*sections.*\)")
self.assertEqual(vs.cols, self.cols)
self.assertEqual(vs.rows, self.rows)
self.assertEqual(vs.sections, self.sections)
self.assertEqual(vs.voxel_count, self.cols * self.rows * self.sections)
def test_get_set_value(self):
"""Test the .value attribute"""
vs = adapter.SFFVolumeStructure(cols=self.cols, rows=self.rows, sections=self.sections)
self.assertEqual(vs.cols, self.cols)
self.assertEqual(vs.rows, self.rows)
self.assertEqual(vs.sections, self.sections)
self.assertEqual(vs.value, (self.cols, self.rows, self.sections))
_c, _r, _s = _random_integer(), _random_integer(), _random_integer()
vs.value = _c, _r, _s
self.assertEqual(vs.value, (_c, _r, _s))
self.assertEqual(vs.cols, _c)
self.assertEqual(vs.rows, _r)
self.assertEqual(vs.sections, _s)
def test_create_from_gds_type(self):
"""Test that we can create from a gds_type"""
_vs = emdb_sff.volume_structure_type(cols=self.cols, rows=self.rows, sections=self.sections)
vs = adapter.SFFVolumeStructure.from_gds_type(_vs)
self.assertRegex(_str(vs), r"SFFVolumeStructure\(cols.*rows.*sections.*\)")
self.assertEqual(vs.cols, self.cols)
self.assertEqual(vs.rows, self.rows)
self.assertEqual(vs.sections, self.sections)
self.assertEqual(vs.voxel_count, self.cols * self.rows * self.sections)
def test_json(self):
# empty
s = adapter.SFFVolumeStructure()
s_json = s.as_json()
s2 = adapter.SFFVolumeStructure.from_json(s_json)
self.assertEqual(s, s2)
# pop'd
rows, cols, sections = _random_integers(start=100, stop=1000, count=3)
s = adapter.SFFVolumeStructure(rows=rows, cols=cols, sections=sections)
s_json = s.as_json()
s2 = adapter.SFFVolumeStructure.from_json(s_json)
self.assertEqual(s, s2)
def test_hff(self):
# empty
vs = adapter.SFFVolumeStructure()
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = vs.as_hff(group)
self.assertIn(u'size', group)
self.assertNotIn(u'size/rows', group)
self.assertNotIn(u'size/cols', group)
self.assertNotIn(u'size/sections', group)
with h5py.File(self.test_hdf5_fn, u'r') as h:
vs2 = adapter.SFFVolumeStructure.from_hff(h[u'container'])
self.assertEqual(vs, vs2)
# non-empty
rows, cols, sections = _random_integers(count=3)
vs = adapter.SFFVolumeStructure(rows=rows, cols=cols, sections=sections)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = vs.as_hff(group)
self.assertIn(u'size', group)
self.assertIn(u'size/rows', group)
self.assertIn(u'size/cols', group)
self.assertIn(u'size/sections', group)
self.assertEqual(group[u'size/rows'][()], rows)
self.assertEqual(group[u'size/cols'][()], cols)
self.assertEqual(group[u'size/sections'][()], sections)
with h5py.File(self.test_hdf5_fn, u'r') as h:
vs2 = adapter.SFFVolumeStructure.from_hff(h[u'container'])
self.assertEqual(vs, vs2)
class TestSFFVolumeIndex(Py23FixTestCase):
def setUp(self):
self.cols = _random_integer()
self.rows = _random_integer()
self.sections = _random_integer()
def test_default(self):
"""Test default settings"""
vi = adapter.SFFVolumeIndex(cols=self.cols, rows=self.rows, sections=self.sections)
self.assertRegex(_str(vi), r"SFFVolumeIndex\(rows.*cols.*sections.*\)")
self.assertEqual(vi.cols, self.cols)
self.assertEqual(vi.rows, self.rows)
self.assertEqual(vi.sections, self.sections)
def test_create_from_gds_type(self):
"""Test that we can create from a gds_type"""
_vi = emdb_sff.volume_index_type(cols=self.cols, rows=self.rows, sections=self.sections)
vi = adapter.SFFVolumeIndex.from_gds_type(_vi)
self.assertRegex(_str(vi), r"SFFVolumeIndex\(rows.*cols.*sections.*\)")
self.assertEqual(vi.cols, self.cols)
self.assertEqual(vi.rows, self.rows)
self.assertEqual(vi.sections, self.sections)
def test_json(self):
# empty
s = adapter.SFFVolumeIndex()
s_json = s.as_json()
s2 = adapter.SFFVolumeIndex.from_json(s_json)
self.assertEqual(s, s2)
# pop'd
rows, cols, sections = _random_integers(start=100, stop=1000, count=3)
s = adapter.SFFVolumeIndex(rows=rows, cols=cols, sections=sections)
s_json = s.as_json()
s2 = adapter.SFFVolumeIndex.from_json(s_json)
self.assertEqual(s, s2)
class TestSFFLattice(Py23FixTestCase):
def setUp(self):
adapter.SFFLattice.reset_id()
self.r, self.c, self.s = _random_integer(start=2, stop=10), _random_integer(start=2, stop=10), _random_integer(
start=2, stop=10)
self.l_mode = u'float64'
self.l_endian = u'little'
self.l_size = adapter.SFFVolumeStructure(rows=self.r, cols=self.c, sections=self.s)
self.l_start = adapter.SFFVolumeIndex(rows=0, cols=0, sections=0)
self.l_data = numpy.random.rand(self.r, self.c, self.s)
self.l_bytes = adapter.SFFLattice._encode(self.l_data, mode=self.l_mode, endianness=self.l_endian)
self.l_unicode = _decode(self.l_bytes, u'utf-8')
def tearDown(self):
adapter.SFFLattice.reset_id()
def test_create_init_array(self):
"""Test that we can create from a numpy array using __init__"""
l = adapter.SFFLattice(
mode=self.l_mode,
endianness=self.l_endian,
size=self.l_size,
start=self.l_start,
data=self.l_data
)
self.assertIsInstance(l, adapter.SFFLattice)
self.assertEqual(l.id, 0)
self.assertEqual(l.mode, self.l_mode)
self.assertEqual(l.endianness, self.l_endian)
self.assertEqual(l.size.voxel_count, self.r * self.c * self.s)
self.assertEqual(l.start.value, (0, 0, 0))
self.assertEqual(l.data, adapter.SFFLattice._encode(self.l_data, mode=self.l_mode, endianness=self.l_endian))
self.assertEqual(l.data_array.flatten().tolist(), self.l_data.flatten().tolist())
self.assertRegex(
_str(l),
r"""SFFLattice\(id=\d+, mode=".*", endianness=".*", size=SFFVolumeStructure\(.*\), start=SFFVolumeIndex\(.*\), data=".*"\)"""
)
import sys
# self.stderr(type(l.data))
l.export(sys.stderr)
def test_create_init_bytes(self):
"""Test that we can create from bytes using __init__"""
l = adapter.SFFLattice(
mode=self.l_mode,
endianness=self.l_endian,
size=self.l_size,
start=self.l_start,
data=self.l_bytes
)
self.assertIsInstance(l, adapter.SFFLattice)
self.assertEqual(l.id, 0)
self.assertEqual(l.mode, self.l_mode)
self.assertEqual(l.endianness, self.l_endian)
self.assertEqual(l.size.voxel_count, self.r * self.c * self.s)
self.assertEqual(l.start.value, (0, 0, 0))
self.assertEqual(l.data, adapter.SFFLattice._encode(self.l_data, mode=self.l_mode, endianness=self.l_endian))
self.assertEqual(l.data_array.flatten().tolist(), self.l_data.flatten().tolist())
self.assertRegex(
_str(l),
r"""SFFLattice\(id=\d+, mode=".*", endianness=".*", size=SFFVolumeStructure\(.*\), start=SFFVolumeIndex\(.*\), data=".*"\)"""
)
def test_create_init_unicode(self):
"""Test that we can create from unicode using __init__"""
l = adapter.SFFLattice(
mode=self.l_mode,
endianness=self.l_endian,
size=self.l_size,
start=self.l_start,
data=self.l_unicode
)
self.assertIsInstance(l, adapter.SFFLattice)
self.assertEqual(l.id, 0)
self.assertEqual(l.mode, self.l_mode)
self.assertEqual(l.endianness, self.l_endian)
self.assertEqual(l.size.voxel_count, self.r * self.c * self.s)
self.assertEqual(l.start.value, (0, 0, 0))
self.assertEqual(l.data, adapter.SFFLattice._encode(self.l_data, mode=self.l_mode, endianness=self.l_endian))
self.assertEqual(l.data_array.flatten().tolist(), self.l_data.flatten().tolist())
self.assertRegex(
_str(l),
r"""SFFLattice\(id=\d+, mode=".*", endianness=".*", size=SFFVolumeStructure\(.*\), start=SFFVolumeIndex\(.*\), data=".*"\)"""
)
def test_create_classmethod_array(self):
"""Test that we can create an object using the classmethod"""
l = adapter.SFFLattice.from_array(
mode=self.l_mode,
endianness=self.l_endian,
size=self.l_size,
start=self.l_start,
data=self.l_data
)
self.assertIsInstance(l, adapter.SFFLattice)
self.assertEqual(l.id, 0)
self.assertEqual(l.mode, self.l_mode)
self.assertEqual(l.endianness, self.l_endian)
self.assertEqual(l.size.voxel_count, self.r * self.c * self.s)
self.assertEqual(l.start.value, (0, 0, 0))
self.assertEqual(_decode(l.data, u'utf-8'),
adapter.SFFLattice._encode(self.l_data, mode=self.l_mode, endianness=self.l_endian))
self.assertEqual(l.data_array.flatten().tolist(), self.l_data.flatten().tolist())
self.stderr(l)
self.assertRegex(
_str(l),
r"""SFFLattice\(id=\d+, mode=".*", endianness=".*", size=SFFVolumeStructure\(.*\), start=SFFVolumeIndex\(.*\), data=".*"\)"""
)
def test_create_classmethod_bytes(self):
"""Test that we can create an object using the classmethod"""
l = adapter.SFFLattice.from_bytes(
self.l_bytes,
self.l_size,
mode=self.l_mode,
endianness=self.l_endian,
start=self.l_start,
)
self.assertIsInstance(l, adapter.SFFLattice)
self.assertEqual(l.id, 0)
self.assertEqual(l.mode, self.l_mode)
self.assertEqual(l.endianness, self.l_endian)
self.assertEqual(l.size.voxel_count, self.r * self.c * self.s)
self.assertEqual(l.start.value, (0, 0, 0))
self.assertEqual(l.data, adapter.SFFLattice._encode(self.l_data, mode=self.l_mode, endianness=self.l_endian))
self.assertEqual(l.data_array.flatten().tolist(), self.l_data.flatten().tolist())
self.assertRegex(
_str(l),
r"""SFFLattice\(id=\d+, mode=".*", endianness=".*", size=SFFVolumeStructure\(.*\), start=SFFVolumeIndex\(.*\), data=".*"\)"""
)
with self.assertRaisesRegex(base.SFFTypeError, r".*is not object of type.*"):
l = adapter.SFFLattice.from_bytes(
self.l_bytes,
(self.r, self.c, self.s),
mode=self.l_mode,
endianness=self.l_endian,
start=self.l_start,
)
def test_from_gds_type(self):
"""Test that all attributes exists when we start with a gds_type"""
r, c, s = _random_integer(start=3, stop=10), _random_integer(start=3, stop=10), _random_integer(start=3,
stop=10)
_data = numpy.random.randint(low=0, high=100, size=(r, c, s))
mode_ = u'uint8'
_bytes = adapter.SFFLattice._encode(_data, endianness=u'big', mode=mode_)
_l = emdb_sff.lattice_type(
mode=mode_,
endianness=u'big',
size=emdb_sff.volume_structure_type(cols=c, rows=r, sections=s),
start=emdb_sff.volume_index_type(cols=0, rows=0, sections=0),
data=_bytes
)
l = adapter.SFFLattice.from_gds_type(_l)
self.assertTrue(hasattr(l, u'data_array'))
def test_json(self):
# empty
l = adapter.SFFLattice()
l_json = l.as_json()
with self.assertRaises(base.SFFTypeError):
l2 = adapter.SFFLattice.from_json(l_json)
# self.assertEqual(l, l2)
# pop'd
rows, cols, sections = _random_integers(start=2, stop=5, count=3)
array = numpy.random.randint(0, 20, size=(rows, cols, sections))
l = adapter.SFFLattice.from_array(array)
l_json = l.as_json()
l2 = adapter.SFFLattice.from_json(l_json)
self.assertEqual(l, l2)
def test_hff(self):
# empty case
l = adapter.SFFLattice()
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = l.as_hff(group)
self.assertIn(u'{}'.format(l.id), group)
self.assertIn(u'{}/id'.format(l.id), group)
self.assertIn(u'{}/mode'.format(l.id), group)
self.assertIn(u'{}/endianness'.format(l.id), group)
self.assertNotIn(u'{}/size'.format(l.id), group)
self.assertIn(u'{}/start'.format(l.id), group)
self.assertNotIn(u'{}/data'.format(l.id), group)
with h5py.File(self.test_hdf5_fn, u'r') as h:
l2 = adapter.SFFLattice.from_hff(h[u'container'])
self.assertEqual(l, l2)
self.assertIsNone(l2.id)
# non-empty case
rows, cols, sections = _random_integers(count=3, start=5, stop=10)
array = numpy.random.randint(0, 10, size=(rows, cols, sections))
l = adapter.SFFLattice.from_array(array)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = l.as_hff(group)
self.assertIn(u'{}'.format(l.id), group)
self.assertIn(u'{}/id'.format(l.id), group)
self.assertIn(u'{}/mode'.format(l.id), group)
self.assertIn(u'{}/endianness'.format(l.id), group)
self.assertIn(u'{}/size'.format(l.id), group)
self.assertIn(u'{}/start'.format(l.id), group)
self.assertIn(u'{}/data'.format(l.id), group)
self.assertEqual(group[u'{}/id'.format(l.id)][()], l.id)
self.assertEqual(_decode(group[u'{}/mode'.format(l.id)][()], 'utf-8'), l.mode)
self.assertEqual(_decode(group[u'{}/endianness'.format(l.id)][()], 'utf-8'), l.endianness)
self.assertEqual(adapter.SFFVolumeStructure.from_hff(group[u'{}'.format(l.id)]), l.size)
self.assertEqual(adapter.SFFVolumeIndex.from_hff(group[u'{}'.format(l.id)]), l.start)
self.assertEqual(_decode(group[u'{}/data'.format(l.id)][()], 'utf-8'), l.data)
with h5py.File(self.test_hdf5_fn, u'r') as h:
for group in h[u'container'].values():
l2 = adapter.SFFLattice.from_hff(group)
self.assertEqual(l, l2)
self.assertIsInstance(l2.id, int)
class TestSFFLatticeList(Py23FixTestCase):
"""Test the SFFLatticeList class"""
@staticmethod
def generate_sff_data(
rows=_random_integer(start=10, stop=20),
cols=_random_integer(start=10, stop=20),
sections=_random_integer(start=10, stop=20)
):
mode = random.choice(list(adapter.FORMAT_CHARS.keys()))
endianness = random.choice(list(adapter.ENDIANNESS.keys()))
size = adapter.SFFVolumeStructure(rows=rows, cols=cols, sections=sections)
start = adapter.SFFVolumeIndex(rows=0, cols=0, sections=0)
if re.match(r".*int.*", mode):
data = numpy.random.randint(0, 100, size=(rows, cols, sections))
elif re.match(r".*float.*", mode):
data = numpy.random.rand(rows, cols, sections)
return mode, endianness, size, start, data
@staticmethod
def generate_gds_data(
rows=_random_integer(start=10, stop=20),
cols=_random_integer(start=10, stop=20),
sections=_random_integer(start=10, stop=20)
):
mode = random.choice(list(adapter.FORMAT_CHARS.keys()))
endianness = random.choice(list(adapter.ENDIANNESS.keys()))
size = emdb_sff.volume_structure_type(rows=rows, cols=cols, sections=sections)
start = emdb_sff.volume_index_type(rows=0, cols=0, sections=0)
if re.match(r".*int.*", mode):
_data = numpy.random.randint(0, 100, size=(rows, cols, sections))
elif re.match(r".*float.*", mode):
_data = numpy.random.rand(rows, cols, sections)
data = adapter.SFFLattice._encode(_data, mode=mode, endianness=endianness)
return mode, endianness, size, start, data
def test_default(self):
"""Test default settings"""
L = adapter.SFFLatticeList()
self.assertRegex(
_str(L),
r"""SFFLatticeList\(\[.*\]\)"""
)
self.assertEqual(len(L), 0)
_no_items = _random_integer(start=2, stop=5)
for _ in _xrange(_no_items):
_mode, _endianness, _size, _start, _data = TestSFFLatticeList.generate_sff_data()
L.append(
adapter.SFFLattice(
mode=_mode,
endianness=_endianness,
size=_size,
start=_start,
data=_data
)
)
self.assertRegex(
_str(L),
r"""SFFLatticeList\(\[SFFLattice\(.*\]\)"""
)
self.assertEqual(len(L), _no_items)
self.assertEqual(list(L.get_ids()), list(_xrange(_no_items)))
l_id = random.choice(list(L.get_ids()))
l = L.get_by_id(l_id)
self.assertIsInstance(l, adapter.SFFLattice)
self.assertEqual(l.id, l_id)
self.assertIn(l.mode, list(adapter.FORMAT_CHARS.keys()))
self.assertIn(l.endianness, list(adapter.ENDIANNESS.keys()))
self.assertIsInstance(l.size, adapter.SFFVolumeStructure)
self.assertIsInstance(l.start, adapter.SFFVolumeIndex)
self.assertIsInstance(l.data, _str)
self.assertIsInstance(l.data_array, numpy.ndarray)
self.assertTrue(len(l.data) > 0)
def test_create_from_gds_type(self):
"""Test that we can create from gds_type"""
_L = emdb_sff.lattice_listType()
_no_items = _random_integer(start=2, stop=5)
_l = list()
for i in _xrange(_no_items):
_mode, _endianness, _size, _start, _data = TestSFFLatticeList.generate_gds_data()
_l.append(
emdb_sff.lattice_type(
id=i,
mode=_mode,
endianness=_endianness,
size=_size,
start=_start,
data=_data
)
)
_L.set_lattice(_l)
L = adapter.SFFLatticeList.from_gds_type(_L)
self.assertRegex(
_str(L),
r"""SFFLatticeList\(\[SFFLattice\(.*\]\)"""
)
self.assertEqual(len(L), _no_items)
self.assertEqual(list(L.get_ids()), list(_xrange(_no_items)))
l_id = random.choice(list(L.get_ids()))
l = L.get_by_id(l_id)
self.assertIsInstance(l, adapter.SFFLattice)
self.assertEqual(l.id, l_id)
self.assertIn(l.mode, list(adapter.FORMAT_CHARS.keys()))
self.assertIn(l.endianness, list(adapter.ENDIANNESS.keys()))
self.assertIsInstance(l.size, adapter.SFFVolumeStructure)
self.assertIsInstance(l.start, adapter.SFFVolumeIndex)
self.assertIsInstance(l.data, _str)
self.assertIsInstance(l.data_array, numpy.ndarray)
self.assertTrue(len(l.data) > 0)
def test_json(self):
"""Test that we can convert back and forth into JSON"""
L = adapter.SFFLatticeList()
_no_lats = _random_integer(start=2, stop=5)
for _ in _xrange(_no_lats):
_mode, _endianness, _size, _start, _data = TestSFFLatticeList.generate_sff_data()
L.append(
adapter.SFFLattice(
mode=_mode,
endianness=_endianness,
size=_size,
start=_start,
data=_data
)
)
L_json = L.as_json()
L2 = adapter.SFFLatticeList.from_json(L_json)
self.assertEqual(L, L2)
def test_hff(self):
# empty case
L = adapter.SFFLatticeList()
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = L.as_hff(group)
self.assertIn(u'lattice_list', group)
self.assertEqual(len(group[u'lattice_list']), 0)
with h5py.File(self.test_hdf5_fn, u'r') as h:
L2 = adapter.SFFLatticeList.from_hff(h[u'container'])
self.assertEqual(L, L2)
# non-empty case
L = adapter.SFFLatticeList()
_no_lats = _random_integer(start=2, stop=15)
for _ in _xrange(_no_lats):
_mode, _endianness, _size, _start, _data = TestSFFLatticeList.generate_sff_data()
L.append(
adapter.SFFLattice(
mode=_mode,
endianness=_endianness,
size=_size,
start=_start,
data=_data
)
)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = L.as_hff(group)
self.assertIn(u'lattice_list', group)
self.assertEqual(len(group[u'lattice_list']), len(L))
for i in _xrange(_no_lats):
self.assertEqual(L[i].mode, _decode(group[u'lattice_list'][_str(i)][u'mode'][()], 'utf-8'))
self.assertEqual(L[i].endianness, _decode(group[u'lattice_list'][_str(i)][u'endianness'][()], 'utf-8'))
self.assertEqual(L[i].size, adapter.SFFVolumeStructure.from_hff(group[u'lattice_list/{}'.format(i)]))
self.assertEqual(L[i].start, adapter.SFFVolumeIndex.from_hff(group[u'lattice_list/{}'.format(i)]))
self.assertEqual(L[i].data, _decode(group[u'lattice_list'][_str(i)][u'data'][()], 'utf-8'))
with h5py.File(self.test_hdf5_fn, u'r') as h:
L2 = adapter.SFFLatticeList.from_hff(h[u'container'])
self.assertEqual(L, L2)
class TestSFFVertices(Py23FixTestCase):
"""SFFVertices tests"""
def setUp(self):
self.num_vertices = _random_integer(start=2, stop=10)
self.mode = u'float64'
self.endian = u'little'
self.data = numpy.random.rand(self.num_vertices, 3)
self.bytes = adapter.SFFVertices._encode(self.data, mode=self.mode, endianness=self.endian)
self.unicode = _decode(self.bytes, u'utf-8')
def test_create_init_array(self):
"""Default configuration"""
v = adapter.SFFVertices(
num_vertices=self.num_vertices,
mode=self.mode,
endianness=self.endian,
data=self.data
)
self.assertIsInstance(v, adapter.SFFVertices)
self.assertEqual(v.mode, self.mode)
self.assertEqual(v.endianness, self.endian)
self.assertIsInstance(v.data, _str)
self.assertEqual(v.data, adapter.SFFVertices._encode(self.data, mode=self.mode, endianness=self.endian))
self.assertEqual(v.data_array.flatten().tolist(), self.data.flatten().tolist())
if len(v.data) < 100:
_data = _decode(v.data, u"utf-8")
else:
_data = _decode(v.data[:100] + u"...", u"utf-8")
self.assertEqual(
_str(v),
u"""SFFVertices(num_vertices={}, mode="{}", endianness="{}", data="{}")""".format(
self.num_vertices,
self.mode,
self.endian,
_data
)
)
with self.assertRaisesRegex(ValueError, r".invalid dimensions.*"):
adapter.SFFVertices(
num_vertices=self.num_vertices,
data=numpy.random.rand(self.num_vertices, 4)
)
def test_create_init_bytes(self):
"""Test that we can create from bytes using __init__"""
v = adapter.SFFVertices(
num_vertices=self.num_vertices,
mode=self.mode,
endianness=self.endian,
data=self.bytes
)
self.assertIsInstance(v, adapter.SFFVertices)
self.assertEqual(v.mode, self.mode)
self.assertEqual(v.endianness, self.endian)
self.assertEqual(v.data, adapter.SFFVertices._encode(self.data, mode=self.mode, endianness=self.endian))
self.assertEqual(v.data_array.flatten().tolist(), self.data.flatten().tolist())
if len(v.data) < 100:
_data = _decode(v.data, u"utf-8")
else:
_data = _decode(v.data[:100] + u"...", u"utf-8")
self.assertEqual(
_str(v),
u"""SFFVertices(num_vertices={}, mode="{}", endianness="{}", data="{}")""".format(
self.num_vertices,
self.mode,
self.endian,
_data
)
)
with self.assertRaisesRegex(ValueError, r".*mismatch.*stated.*retrieved.*"):
v = adapter.SFFVertices(
num_vertices=self.num_vertices * 2,
mode=self.mode,
endianness=self.endian,
data=self.bytes
)
def test_create_init_unicode(self):
"""Test that we can create from unicode using __init__"""
v = adapter.SFFVertices(
num_vertices=self.num_vertices,
mode=self.mode,
endianness=self.endian,
data=self.unicode
)
self.assertIsInstance(v, adapter.SFFVertices)
self.assertEqual(v.mode, self.mode)
self.assertEqual(v.endianness, self.endian)
self.assertEqual(v.data, adapter.SFFVertices._encode(self.data, mode=self.mode, endianness=self.endian))
self.assertEqual(v.data_array.flatten().tolist(), self.data.flatten().tolist())
if len(v.data) < 100:
_data = _decode(v.data, u"utf-8")
else:
_data = _decode(v.data[:100] + u"...", u"utf-8")
self.assertEqual(
_str(v),
u"""SFFVertices(num_vertices={}, mode="{}", endianness="{}", data="{}")""".format(
self.num_vertices,
self.mode,
self.endian,
_data
)
)
with self.assertRaisesRegex(ValueError, r".*mismatch.*stated.*retrieved.*"):
v = adapter.SFFVertices(
num_vertices=self.num_vertices * 2,
mode=self.mode,
endianness=self.endian,
data=self.bytes
)
def test_create_classmethod_array(self):
"""Test that we can create an object using the classmethod"""
v = adapter.SFFVertices.from_array(
data=self.data,
mode=self.mode,
endianness=self.endian,
)
self.assertIsInstance(v, adapter.SFFVertices)
self.assertEqual(v.mode, self.mode)
self.assertEqual(v.endianness, self.endian)
self.assertEqual(v.data, adapter.SFFVertices._encode(self.data, mode=self.mode, endianness=self.endian))
self.assertEqual(v.data_array.flatten().tolist(), self.data.flatten().tolist())
if len(v.data) < 100:
_data = _decode(v.data, u"utf-8")
else:
_data = _decode(v.data[:100] + u"...", u"utf-8")
self.assertEqual(
_str(v),
u"""SFFVertices(num_vertices={}, mode="{}", endianness="{}", data="{}")""".format(
self.num_vertices,
self.mode,
self.endian,
_data,
)
)
def test_create_classmethod_bytes(self):
"""Test that we can create an object using the classmethod"""
v = adapter.SFFVertices.from_bytes(
self.bytes,
self.num_vertices,
mode=self.mode,
endianness=self.endian,
)
self.assertIsInstance(v, adapter.SFFVertices)
self.assertEqual(v.mode, self.mode)
self.assertEqual(v.endianness, self.endian)
self.assertEqual(v.data, adapter.SFFVertices._encode(self.data, mode=self.mode, endianness=self.endian))
self.assertEqual(v.data_array.flatten().tolist(), self.data.flatten().tolist())
if len(v.data) < 100:
_data = _decode(v.data, u"utf-8")
else:
_data = _decode(v.data[:100] + u"...", u"utf-8")
self.assertEqual(
_str(v),
u"""SFFVertices(num_vertices={}, mode="{}", endianness="{}", data="{}")""".format(
self.num_vertices,
self.mode,
self.endian,
_data
)
)
def test_dict_interface(self):
"""Test the dictionary interface"""
v = adapter.SFFVertices(
num_vertices=self.num_vertices,
mode=self.mode,
endianness=self.endian,
data=self.data
)
index = _random_integer(start=0, stop=self.num_vertices - 1)
self.assertTrue(numpy.array_equal(self.data[index], v[index]))
def test_from_gds_type(self):
"""Test that we can create an object direct from gds_type"""
_v = emdb_sff.vertices_type(
num_vertices=self.num_vertices,
mode=self.mode,
endianness=self.endian,
data=self.bytes
)
v = adapter.SFFVertices.from_gds_type(_v)
self.assertEqual(v.num_vertices, self.num_vertices)
self.assertTrue(hasattr(v, u'data_array'))
self.assertIsInstance(v.data_array, numpy.ndarray)
def test_json(self):
"""Interconversion to JSON"""
v = adapter.SFFVertices(
num_vertices=self.num_vertices,
mode=self.mode,
endianness=self.endian,
data=self.data
)
v_json = v.as_json()
self.assertEqual(v_json, {
u'num_vertices': self.num_vertices,
u'mode': self.mode,
u'endianness': self.endian,
u'data': _decode(self.bytes, 'ASCII'),
})
v2 = adapter.SFFVertices.from_json(v_json)
self.assertEqual(v, v2)
def test_hff(self):
# empty
v = adapter.SFFVertices()
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = v.as_hff(group)
self.assertIn(u'vertices', group)
self.assertNotIn(u'vertices/num_vertices', group)
self.assertIn(u'vertices/mode', group)
self.assertIn(u'vertices/endianness', group)
self.assertNotIn(u'vertices/data', group)
with h5py.File(self.test_hdf5_fn, u'r') as h:
v2 = adapter.SFFVertices.from_hff(h[u'container'])
self.assertEqual(v, v2)
# non-empty
v = adapter.SFFVertices(
num_vertices=self.num_vertices,
mode=self.mode,
endianness=self.endian,
data=self.data
)
with h5py.File(self.test_hdf5_fn, u'w') as h:
group = h.create_group(u'container')
group = v.as_hff(group)
self.assertIn(u'vertices', group)
self.assertIn(u'vertices/num_vertices', group)
self.assertEqual(group[u'vertices/num_vertices'][()], v.num_vertices)
self.assertIn(u'vertices/mode', group)
self.assertEqual(_decode(group[u'vertices/mode'][()], 'utf-8'), v.mode)
self.assertIn(u'vertices/endianness', group)
self.assertEqual(_decode(group[u'vertices/endianness'][()], 'utf-8'), v.endianness)
self.assertIn(u'vertices/data', group)
self.assertEqual(_decode(group[u'vertices/data'][()], 'utf-8'), v.data)
with h5py.File(self.test_hdf5_fn, u'r') as h:
v2 = adapter.SFFVertices.from_hff(h[u'container'])
self.assertEqual(v, v2)
class TestSFFNormals(Py23FixTestCase):
"""SFFNormals tests"""
def setUp(self):
self.num_normals = _random_integer(start=2, stop=10)
self.mode = u'float64'
self.endian = u'little'
self.data = | numpy.random.rand(self.num_normals, 3) | numpy.random.rand |
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import six
from .utils import cKDTree, guess_pos_columns
import numpy as np
from pandas import DataFrame
from .utils import pandas_concat
# Maximum number of elements in the array of all distances.
# Should be roughly (bytes of available memory)/16
MAX_ARRAY_SIZE = 1e8
def proximity(features, pos_columns=None):
"""Find the distance to each feature's nearest neighbor.
Parameters
----------
features : DataFrame
pos_columns : list of column names
['x', 'y'] by default
Returns
-------
proximity : DataFrame
distance to each particle's nearest neighbor,
indexed by particle if 'particle' column is present in input
Examples
--------
Find the proximity of each particle to its nearest neighbor in every frame.
>>> prox = t.groupby('frame').apply(proximity).reset_index()
>>> avg_prox = prox.groupby('particle')['proximity'].mean()
And filter the trajectories...
>>> particle_nos = avg_prox[avg_prox > 20].index
>>> t_filtered = t[t['particle'].isin(particle_nos)]
"""
if pos_columns is None:
pos_columns = ['x', 'y']
leaf_size = max(1, int(np.round(np.log10(len(features)))))
tree = cKDTree(features[pos_columns].copy(), leaf_size)
proximity = tree.query(tree.data, 2)[0][:, 1]
result = DataFrame({'proximity': proximity})
if 'particle' in features:
result.set_index(features['particle'], inplace=True)
return result
def pair_correlation_2d(feat, cutoff, fraction=1., dr=.5, p_indices=None,
ndensity=None, boundary=None, handle_edge=True,
max_rel_ndensity=10):
"""Calculate the pair correlation function in 2 dimensions.
Parameters
----------
feat : Pandas DataFrame
DataFrame containing the x and y coordinates of particles
cutoff : float
Maximum distance to calculate g(r)
fraction : float, optional
The fraction of particles to calculate g(r) with. May be used to
increase speed of function. Particles selected at random.
dr : float, optional
The bin width
p_indices : list or ndarray, optional
Only consider a pair of particles if one of them is in 'p_indices'.
Uses zero-based indexing, regardless of how 'feat' is indexed.
ndensity : float, optional
Density of particle packing. If not specified, density will be
calculated assuming rectangular homogeneous arrangement.
boundary : tuple, optional
Tuple specifying rectangular prism boundary of particles (xmin, xmax,
ymin, ymax). Must be floats. Default is to assume a rectangular packing.
Boundaries are determined by edge particles.
handle_edge : boolean, optional
If true, compensate for reduced area around particles near the edges.
max_rel_ndensity : number, optional
The relative maximum density deviation, used to estimate the maximum
number of neighbours. Lower numbers increase performance, until the
method fails because there are more neighbours than expected.
Returns
-------
r_edges : array
The bin edges, with 1 more element than g_r.
g_r : array
The values of g_r.
"""
if boundary is None:
xmin, xmax, ymin, ymax = (feat.x.min(), feat.x.max(),
feat.y.min(), feat.y.max())
else:
xmin, xmax, ymin, ymax = boundary
# Disregard all particles outside the bounding box
feat = feat[(feat.x >= xmin) & (feat.x <= xmax) &
(feat.y >= ymin) & (feat.y <= ymax)]
if ndensity is None: # particle packing density
ndensity = (feat.x.count() - 1) / ((xmax - xmin) * (ymax - ymin))
if p_indices is None:
if fraction == 1.:
p_indices = slice(len(feat))
else: # grab random sample of particles
p_indices = np.random.randint(0, len(feat),
int(fraction * len(feat)))
# radii bins to search for particles
r_edges = np.arange(0, cutoff + dr, dr)
# initialize kdtree for fast neighbor search
ckdtree = cKDTree(feat[['x', 'y']])
pos = ckdtree.data[p_indices]
# Estimate upper bound for neighborhood particle count
max_p_count = int(np.pi * (r_edges.max() + dr)**2 *
ndensity * max_rel_ndensity)
# Protect against too large memory usage
if len(pos) * max_p_count > MAX_ARRAY_SIZE:
raise MemoryError('The distance array will be larger than the maximum '
'allowed size. Please reduce the cutoff or '
'max_rel_ndensity. Or run the analysis on a fraction '
'of the features using the fraction parameter.')
dist, idxs = ckdtree.query(pos, k=max_p_count, distance_upper_bound=cutoff)
if np.any(np.isfinite(dist[:, -1])):
raise RuntimeError("There are too many particle pairs per particle. "
"Apparently, density fluctuations are larger than "
"max_rel_ndensity. Please increase it.")
# drop zero and infinite dist values
mask = (dist > 0) & np.isfinite(dist)
dist = dist[mask]
if handle_edge:
pos_repeated = pos[:, np.newaxis].repeat(max_p_count, axis=1)[mask]
arclen = arclen_2d_bounded(dist, pos_repeated,
np.array([[xmin, xmax], [ymin, ymax]]))
else:
arclen = 2*np.pi*dist
g_r = np.histogram(dist, bins=r_edges, weights=1/arclen)[0]
return r_edges, g_r / (ndensity * len(pos) * dr)
def pair_correlation_3d(feat, cutoff, fraction=1., dr=.5, p_indices=None,
ndensity=None, boundary=None, handle_edge=True,
max_rel_ndensity=10):
"""Calculate the pair correlation function in 3 dimensions.
Parameters
----------
feat : Pandas DataFrame
DataFrame containing the x, y and z coordinates of particles
cutoff : float
Maximum distance to calculate g(r)
fraction : float, optional
The fraction of particles to calculate g(r) with. May be used to
increase speed of function. Particles selected at random.
dr : float, optional
The bin width
p_indices : list or ndarray, optional
Only consider a pair of particles if one of them is in 'p_indices'.
Uses zero-based indexing, regardless of how 'feat' is indexed.
ndensity : float, optional
Density of particle packing. If not specified, density will be
calculated assuming rectangular homogeneous arrangement.
boundary : tuple, optional
Tuple specifying rectangular boundary of particles (xmin, xmax,
ymin, ymax, zmin, zmax). Must be floats. Default is to assume a
rectangular packing. Boundaries are determined by edge particles.
handle_edge : boolean, optional
If true, compensate for reduced volume around particles near the edges.
max_rel_ndensity : number, optional
The relative maximum density deviation, used to estimate the maximum
number of neighbours. Lower numbers increase performance, until the
method fails because there are more neighbours than expected.
Returns
-------
r_edges : array
The bin edges, with 1 more element than g_r.
g_r : array
The values of g_r.
"""
if boundary is None:
xmin, xmax, ymin, ymax, zmin, zmax = (feat.x.min(), feat.x.max(),
feat.y.min(), feat.y.max(),
feat.z.min(), feat.z.max())
else:
xmin, xmax, ymin, ymax, zmin, zmax = boundary
# Disregard all particles outside the bounding box
feat = feat[(feat.x >= xmin) & (feat.x <= xmax) &
(feat.y >= ymin) & (feat.y <= ymax) &
(feat.z >= zmin) & (feat.z <= zmax)]
if ndensity is None: # particle packing density
ndensity = (feat.x.count() - 1) / \
((xmax - xmin) * (ymax - ymin) * (zmax - zmin))
if p_indices is None:
if fraction == 1.:
p_indices = slice(len(feat))
else: # grab random sample of particles
p_indices = np.random.randint(0, len(feat),
int(fraction * len(feat)))
# radii bins to search for particles
r_edges = np.arange(0, cutoff + dr, dr)
# initialize kdtree for fast neighbor search
ckdtree = cKDTree(feat[['x', 'y', 'z']])
pos = ckdtree.data[p_indices]
# Estimate upper bound for neighborhood particle count
max_p_count = int((4./3.) * np.pi * (r_edges.max() + dr)**3 *
ndensity * max_rel_ndensity)
# Protect against too large memory usage
if len(pos) * max_p_count > MAX_ARRAY_SIZE:
raise MemoryError('The distance array will be larger than the maximum '
'allowed size. Please reduce the cutoff or '
'max_rel_ndensity. Or run the analysis on a fraction '
'of the features using the fraction parameter.')
dist, idxs = ckdtree.query(pos, k=max_p_count, distance_upper_bound=cutoff)
if np.any(np.isfinite(dist[:, -1])):
raise RuntimeError("There are too many particle pairs in the frame. "
"Please reduce the cutoff distance, increase "
"max_rel_ndensity, or use a fraction.")
# drop zero and infinite dist values
mask = (dist > 0) & np.isfinite(dist)
dist = dist[mask]
if handle_edge:
pos_repeated = pos[:, np.newaxis].repeat(max_p_count, axis=1)[mask]
area = area_3d_bounded(dist, pos_repeated,
np.array([[xmin, xmax], [ymin, ymax],
[zmin, zmax]]))
else:
area = 4*np.pi*dist**2
g_r = np.histogram(dist, bins=r_edges, weights=1/area)[0]
return r_edges, g_r / (ndensity * len(pos) * dr)
def circle_cap_arclen(h, r):
""" Length of a circle arc of circle with radius R that is bounded by
a straight line `h` from the origin. h >= 0, h < R"""
return 2*r*np.arccos(h / r)
def circle_corner_arclen(h1, h2, r):
""" Length of a circle arc of circle with radius R that is bounded by
two perpendicular straight lines `h1` and `h2` from the origin.
h1**2 + h2**2 < R**2
h1 >= R
h2 >= R
"""
return r*(np.arccos(h2 / r) - np.arcsin(h1 / r))
def sphere_cap_area(h, r):
""" Area of a sphere cap of sphere with radius R that is bounded by
a flat plane `h` from the origin. h >= 0, h < R"""
return 2*np.pi*r*(r-h)
def sphere_edge_area(x, y, r):
""" Area of a sphere 'edge' of sphere with radius R that is bounded by
two perpendicular flat planes `h0`, `h1` from the origin. h >= 0, h < R"""
p = np.sqrt(r**2 - x**2 - y**2)
A = (r - x - y)*np.pi - 2*r*np.arctan(x*y/(p*r)) + \
2*x*np.arctan(y/p) + 2*y*np.arctan(x/p)
return A*r
def sphere_corner_area(x, y, z, r):
""" Area of a sphere 'corner' of sphere with radius R that is bounded by
three perpendicular flat planes `h0`, `h1`, `h2` from the origin. """
pxy = np.sqrt(r**2 - x**2 - y**2)
pyz = np.sqrt(r**2 - y**2 - z**2)
pxz = np.sqrt(r**2 - x**2 - z**2)
A = np.pi*(r - x - y - z)/2 + \
x*(np.arctan(y/pxy) + np.arctan(z/pxz)) - r*np.arctan(y*z/(r*pyz)) + \
y*(np.arctan(x/pxy) + np.arctan(z/pyz)) - r*np.arctan(x*z/(r*pxz)) + \
z*(np.arctan(x/pxz) + np.arctan(y/pyz)) - r* | np.arctan(x*y/(r*pxy)) | numpy.arctan |
""" This module
"""
import numpy, math
from numpy import log10 as log10
from numpy import pi as pi
from scipy.interpolate import UnivariateSpline as interpolate
from scipy.optimize import curve_fit as cf
from scipy.optimize import minimize
from scipy.integrate import simps, quad
from pmesh.particlemesh import ParticleMesh
import sys
sys.path.append("/global/homes/c/chmodi/Programs/Py_codes/modules/")
import mytools as tools
import matplotlib.pyplot as plt
from matplotlib.colors import LogNorm, SymLogNorm
from sklearn import svm
##slope = 0
intercept = 0
#########################################################################
def sm_scale(mass, ovd = 178., rhoc = 27.756, M = 0.3175):
'''Return Eulerian scale of the halo for solar mass'''
rhobar = ovd * rhoc*M*10**10.
return (3 * mass / (4*numpy.pi*rhobar))**(1/3.)
def sigmoidf(delta, hold, alpha = 0.8, b = 1):
'''Pass delta through a sigmoid of threshold = hold, multiplicative coeff = alpha, power = b'''
z = alpha * (delta**b - hold**b)
return 1./(1 + numpy.exp(-z))
def normalize(ar):
'''Normalize the array by subtracting the mean and dividing by std
'''
mean = ar.mean()
std = ar.std()
return (ar - mean)/std
def svm_thresh(ft, cls, cls_wt = None):
'''Do the svm on the ft(feature) and cl(ass)
'''
if cls_wt is None:
clf = svm.LinearSVC(max_iter=10000, dual = False)
else:
clf = svm.LinearSVC(max_iter=10000, dual = False, class_weight = cls_wt)
clf.fit(ft, cls)
return clf.coef_[0], clf.intercept_[0], clf.score(ft, cls)
def find_mask(ftlist, cls, mesh, catpos, alpha = 20., b = 1, file = None, label = "None", cls_wt = None, NN = False):
'''Find mask passed through sigmoid'''
mesh.push()
nft = len(ftlist)
ft = numpy.empty([cls.size, nft])
if NN:
nc = mesh.real.shape[0]
bs = mesh.BoxSize[0]
side = bs/nc
pos = numpy.round(catpos/side).astype(int)
pos[pos == nc] = 0
for foo in range(nft):
ft[:, foo] = ftlist[foo][tuple(pos.T)]
else:
for foo in range(nft):
mesh.clear()
mesh.real[:] = ftlist[foo]
ft[:, foo] = mesh.readout(catpos)
coeff, intercept, score = svm_thresh(ft, cls, cls_wt)
if file is not None:
file.write("label = %s , nft = %d\n"%(label, nft))
file.write("coeff = %s, intercept = %s \n"%(str(coeff), str(intercept)))
file.write("threshold = %s, score = %0.3f \n"%(str(intercept/coeff[0]), score))
pmgrid = numpy.zeros_like(mesh.real)
for foo in range(nft):
pmgrid += coeff[foo]*ftlist[foo]
mask = sigmoidf(pmgrid, -intercept, alpha, b)
mesh.pop()
return mask, coeff, intercept
def crosspower(mesh1, mesh2, bs, a1 = False, a2 = False, cross = True, normit = False, std1 = False, unlog = False, ovd1 = False, ovd2 = False):
pmesh1 = mesh1.copy()
pmesh2 = mesh2.copy()
if unlog:
pmesh1 =10**pmesh1
pmesh2 =10**pmesh2
if normit:
pmesh1 = normalize(pmesh1)
pmesh2 = normalize(pmesh2)
if pmesh1.mean() < 10**-6:
pmesh1 += 1
if pmesh2.mean() < 10**-6:
pmesh2 += 1
if std1:
pmesh1 = pmesh1/pmesh1.std()
pmesh2 = pmesh2/pmesh2.std()
add1 = 0
add2 = 0
if a1:
k, pow1 = tools.power_cheap(pmesh1 + add1, boxsize = bs)
if a2:
k, pow2 = tools.power_cheap(pmesh2 + add2, boxsize = bs)
if cross:
k, powc = tools.power_cheap(pmesh1 + add1, pmesh2 + add2, boxsize = bs)
toret = [k]
if a1:
toret.append(pow1)
if a2:
toret.append(pow2)
if cross:
toret.append(powc)
return toret
#########################################################################
###Different style of painting and other array transformations
def grid(mesh, pos = None, wts = None, style = 'CIC', ingrid = None, logscale = False,
dolog = False, smooth = None, R=0, dologsm = False):
mesh.push()
if pos is None:
if ingrid is None:
return 'No input given! Give either position or a grid to operate on.'
else:
mesh.clear()
mesh.real[:] = ingrid[:]
if logscale:
mesh.real[:] = 10**mesh.real[:]
mesh.real[mesh.real == 1] = 0
else:
if wts is None:
wts = numpy.ones(pos.shape[0])
mesh.clear()
if style == 'CIC':
mesh.paint(pos, mass = wts)
elif style == 'NN':
nc = mesh.real.shape[0]
mesh.real[:], dummy = numpy.histogramdd(pos, bins = (nc, nc, nc), weights=wts)
toret = mesh.real.copy()
if dolog:
dummy = numpy.empty_like(toret)
dummy[:] = toret[:]
dummy[dummy <= 0] = 1
dummy = log10(dummy)
toret2 = dummy.copy()
if smooth is not None:
mesh.clear()
mesh.real[:] = toret[:]
mesh.r2c()
if smooth == 'Fingauss':
mesh.transfer([tools.pmFingauss(R)])
elif smooth == 'Gauss':
mesh.transfer([tools.pmGauss(R)])
elif smooth == 'Tophat':
mesh.transfer([tools.pmTophat(R)])
else:
return 'Smoothing kernel not defined'
mesh.c2r()
toret3 = mesh.real.copy()
if dologsm:
dummy = numpy.empty_like(toret3)
dummy[:] = toret3[:]
dummy[dummy <= 0] = 1
dummy = log10(dummy)
toret4 = dummy.copy()
mesh.pop()
if dolog:
if smooth:
if dologsm:
return toret, toret2, toret3, toret4
else:
return toret, toret2, toret3
else:
return toret, toret2
elif smooth:
if dologsm:
return toret, toret3, toret4
else:
return toret, toret3
else:
return toret
#########################################################################
#### Stellar Mass
def line(x, m , c):
return m*x + c
def scatter(hmass, sigma, seed = 123):
'''Take in halo mass in solar mass and return the log-normally scattered mass
'''
logl = numpy.log10(hmass)
rng = numpy.random.RandomState(seed)
t = rng.normal(scale=sigma, size=len(logl))
logl = logl + t
return 10**logl
def stellar_relation():
x1 = 10**15 * 1.6
x2 = 10**12 * 4
y1 = x1 * 1.5*10**-3
y2 = x2 * 3.2*10**-2
line1, dummy = cf(line, numpy.array([log10(x1), log10(x2)]), numpy.array([log10(y1), log10(y2)]))
y1 = x1 * 3.5*10**-4
y2 = x2 * 2.2*10**-2
line2, dummy = cf(line, numpy.array([log10(x1), log10(x2)]), numpy.array([log10(y1), log10(y2)]))
#mean line
m = (line1[0] + line2[0])*0.5
c = (line1[1] + line2[1])*0.5
xval = numpy.linspace(log10(x2), log10(x1))
xline = line(xval, m, c)
stellar_sigma = interpolate(xline, 0.01 + (line(xval, line1[0], line1[1]) - xline))
return stellar_sigma, m, c
def htostar(hmass, seed = 123, stellar_sigma = stellar_relation()[0], slope = stellar_relation()[1],\
intercept = stellar_relation()[2]):
'''Take in halo mass in solar mass and return the stellar mass in solar mass.
'''
logh = numpy.log10(hmass)
rng = numpy.random.RandomState(seed)
logs = logh*slope + intercept
testf = lambda x : rng.normal(0, x, 1)
logs = logs + numpy.array(list(map(testf, stellar_sigma(logs)))).T
return 10**logs[0, :]
def twiddle(halomass, sigma, seed=12345):
length = halomass.copy()
logl = numpy.log10(length)
rng = numpy.random.RandomState(seed)
t = rng.normal(scale=sigma, size=len(logl))
logl = logl + t
# logl[0] = np.inf
arg = logl.argsort()[::-1]
halos = halomass[arg].copy()
return halos, arg
#########################################################################
###Functions for fitting mass
def fit_log(x, *p):
''' y = b*numpy.log10(1 + a*x) + c'''
a, b, c = p
x2 = numpy.log10(1 + a*x)
return b*x2 + c
def quad_exp(x, *p):
'''y = 10**z *(ax**2 + b*x + c)'''
a, b, c, y = p
return (10**y) * (a*x**2 + b*x+ c )
def chi_sqf(p, xdata, ydata, sigma):
model = quad_exp(xdata, *p)
return (((model - ydata)/sigma)**2).sum()
def quad_exp_der(p, xdata, ydata, sigma):
model = quad_exp(xdata, *p)
fac = (2*(model - ydata)/sigma)
a, b, c, y = p
#a, b, c, y = p; model = (10**y) * (a*x**2 + b*x+ c )
dmdy = numpy.log(10)*model*fac
dmda = (10**y)*(xdata**2)*fac
dmdb = (10**y)*xdata*fac
dmdc = (10**y)*fac
return numpy.array([dmda.sum(), dmdb.sum(), dmdc.sum(), dmdy.sum()]).T
def domass_10min(Y, X, func = chi_sqf, p0 = [1, 1, 1, 1], lim = False, sigma = True, absig = False, \
abund = False, retdata = False, nonzeroy = True, ranzero = 0, tol = 0):
xdata = X.astype("float64").flatten()
ydata = Y.astype("float64").flatten()
if nonzeroy:
pos = numpy.where(ydata > 0)[0]
ydata = ydata[pos]
xdata = xdata[pos]
if abund:
xdata = numpy.sort(xdata)[::-1]
ydata = numpy.sort(ydata)[::-1]
if lim:
pos = numpy.where(ydata > (lim))[0]
ydata = ydata[pos]
xdata = xdata[pos]
if ranzero:
posz = numpy.where(ydata == 0)[0]
posz = numpy.random.permutation(posz)
pos = numpy.concatenate((pos, posz[:int(ranzero*Y.size/100)]))
if sigma:
sigmaval = ydata.copy()
sigmaval[sigmaval == 0] = 1
else:
sigmaval = numpy.ones_like(ydata)
# res = minimize(func, x0 = p0, args =(xdata, ydata, sigmaval), jac = quad_exp_der,\
# method='L-BFGS-B', options = {'ftol' : 10**-15, 'gtol':10**-10})
res = minimize(func, x0 = p0, args =(xdata, ydata, sigmaval), jac = quad_exp_der,\
method='BFGS', options = {'gtol':10**-10})
# if tol:
# res = minimize(func, x0 = p0, args =(xdata, ydata, sigmaval), method = 'Nelder-Mead', tol=10**-10)
# else:res = minimize(func, x0 = p0, args =(xdata, ydata, sigmaval), method = 'Nelder-Mead', options ={'fatol':0.0001})
print(res.message, res.nit)
sigmass = quad_exp(X, *res.x)
if retdata:
return sigmass, res.x, xdata, ydata
else:
return sigmass, res.x
def domass(Y, X, func = fit_log, p0 = [1, 2, 8], lim = False, loglim = False, sigma = True, absig = False, \
abund = False, retdata = False, nonzeroy = True, ranzero = 0):
'''Take in X(delta) & Y(loghalo) field and fit with function 'func' and starting parameter 'p0'
'''
xdata = X.flatten()
ydata = Y.flatten()
if nonzeroy:
pos = numpy.where(ydata > 0)[0]
if ranzero:
posz = numpy.where(ydata == 0)[0]
posz = numpy.random.permutation(posz)
pos = numpy.concatenate((pos, posz[:int(ranzero*Y.size/100)]))
ydata = ydata[pos]
xdata = xdata[pos]
if abund:
#xdata = xdata[xdata > 0].flatten()
#ydata = ydata[ydata > 0].flatten()
xdata = numpy.sort(xdata)[::-1]
ydata = numpy.sort(ydata)[::-1]
if lim:
pos = numpy.where(ydata > (lim))[0]
ydata = ydata[pos]
xdata = xdata[pos]
if loglim:
pos = numpy.where(ydata > | log10(lim) | numpy.log10 |
# -*- coding: utf-8 -*-
"""
Created on Mon Dec 6 19:54:46 2021
@author: GSung
"""
import pytest
import numpy as np
from src.AutomaticDifferentiation.ReverseAD import ReverseAD
from src.AutomaticDifferentiation.ReverseAD import ReverseFunctions
class TestFunctions:
##########################################
# __init__
def test_init_value(self):
"""check that variables can be initialized correctly"""
x = ReverseAD(4)
assert x.value == 4
def test_init_grad(self):
"""check that variables can be initialized correctly"""
x = ReverseAD(4)
assert x.local_gradients == [(None,1)]
##########################################
# add
def test_add_value(self):
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([x + y, y + z + 2], [x,y,z])
assert f.vals == [5,9]
def test_add_ders(self):
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([x + y, y + z + 2], [x, y, z])
assert np.array_equal(f.ders, np.array([[1, 1, 0],[0, 1, 1]]))
def test_add_label(self):
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([x + y, y + z + 2], [x, y, z])
assert f.vars == ['x','y','z']
def test_radd_value(self):
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([3 + x, y + z], [x, y, z])
assert f.vals == [5,7]
def test_radd_ders(self):
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([3 + x, y + z], [x, y, z])
assert np.array_equal(f.ders, np.array([[1, 0, 0],[0, 1, 1]]))
def test_radd_label(self):
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([x + y, 2 + y], [x, y])
assert f.vars == ['x','y']
##########################################
# Subtraction
def test_sub_val(self):
"""check that __add__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([x - 3.0, x + y])
assert f.vals == [-1.0, 5]
def test_sub_der(self):
"""check that __add__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([x - 3.0, x + y], [x, y])
assert np.array_equal(f.ders,np.array([[1, 0],[1,1]]))
def test_sub_label(self):
"""check that __add__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([x - 3.0, x + y], [x, y])
assert f.vars == ['x','y']
def test_rsub_val(self):
"""check that __radd__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([3.0 - x, x - y, y - x],[x,y])
assert np.array_equal(f.vals, [1, -1, 1])
def test_rsub_der(self):
"""check that __radd__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([3.0 - x, x - y, y - x],[x,y])
assert np.array_equal(f.ders,[[-1,0], [1,-1],[-1, 1]])
def test_rsub_label(self):
"""check that __radd__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([3.0 - x, x - y, y - x],[x,y])
assert f.vars == ['x', 'y']
##########################################
# multiplication
def test_mul_val(self):
"""check that __mul__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([x * 3, x * y, y * x], [x,y])
assert f.vals == [6.0,6.0,6.0]
def test_mul_der(self):
"""check that __mul__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([x * 3, x * y, y * x], [x,y])
assert np.array_equal(f.ders, [[3.0,0],[3.0,2.0],[3.0, 2.0]])
def test_mul_label(self):
"""check that __mul__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([x * 3, x * y, y * x], [x,y])
assert f.vars == ['x','y']
def test_rmul_val(self):
"""check that __rmul__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([3 * x, x * y, y * x], [x,y])
assert f.vals == [6,6,6]
def test_rmul_der(self):
"""check that __rmul__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([3 * x, x * y, y * x], [x,y])
assert np.array_equal(f.ders, [[3,0],[3,2],[3, 2]])
def test_rmul_label(self):
"""check that __rmul__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([3 * x, x * y, y * x], [x,y])
assert f.vars == ['x','y']
##########################################
# Inversion
def test_inv_val(self):
"""check that __truediv__ has been overwritten correctly"""
x = ReverseAD(2, label="x")
f = ReverseFunctions([2 / x],[x])
assert f.vals == [1]
def test_inv_der(self):
"""check that __truediv__ has been overwritten correctly"""
x = ReverseAD(2, label="x")
f = ReverseFunctions([2 / x],[x])
assert np.array_equal(f.ders, [[-0.5]])
def test_inv_label(self):
"""check that __truediv__ has been overwritten correctly"""
x = ReverseAD(2, label="x")
f = ReverseFunctions([2 / x],[x])
assert f.vars == ['x']
##########################################
# true division
#TODO
def test_truediv_val(self):
"""check that __truediv__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([x / 2, x / z], [x, z])
assert f.vals == [1.0,0.5]
def test_truediv_der(self):
"""check that __truediv__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([x / 2, x / z], [x, z])
assert np.array_equal(f.ders, [[0.5, 0],[0.25, -0.125]])
def test_truediv_label(self):
"""check that __truediv__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([x / 2, x / z], [x, z])
assert f.vars == ['x','z']
##########################################
# negation
def test_neg_val(self):
"""check that __truediv__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([-x / 2, -z], [x,z])
assert f.vals == [-1.0, -4]
def test_neg_der(self):
"""check that __truediv__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([-x / 2, -z], [x,z])
assert np.array_equal(f.ders, [[-0.5, 0], [0, -1]])
def test_neg_label(self):
"""check that __truediv__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
z = ReverseAD(4, label = "z")
f = ReverseFunctions([-x / 2, -z], [x,z])
assert f.vars == ['x','z']
##########################################
# power
def test_pow_val(self):
"""check that __pow__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(2, label = "y")
f = ReverseFunctions([x ** 2, (x + y) ** 2], [x, y])
assert f.vals == [4, 16]
def test_pow_der(self):
"""check that __mul__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(2, label = "y")
f = ReverseFunctions([x ** 2, (x + y) ** 2], [x, y])
assert np.array_equal(f.ders, [[4.0,0],[8, 8]])
def test_pow_label(self):
"""check that __mul__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(2, label = "y")
f = ReverseFunctions([x ** 2, (x + y) ** 2], [x, y])
assert f.vars == ['x','y']
def test_rpow_val(self):
"""check that __rmul__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(2, label = "y")
f = ReverseFunctions([2 ** x, 2**(x + y)], [x, y])
assert f.vals == [4, 16]
def test_rpow_der(self):
"""check that __rmul__ has been overwritten correctly"""
x = ReverseAD(2, label = "x")
y = ReverseAD(3, label = "y")
f = ReverseFunctions([2 ** x, 2**(x + y)], [x, y])
assert np.array_equal(f.ders, [[np.log(2)*2*2,0],[ | np.log(2) | numpy.log |
# Copyright 2017 The UAI-SDK 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 __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import json
import StringIO
import numpy as np
import tensorflow as tf
from PIL import Image
from uai.arch.tf_model import TFAiUcloudModel
class MnistModel(TFAiUcloudModel):
def __init__(self, conf):
super(MnistModel, self).__init__(conf)
def load_model(self):
sess = tf.Session()
x = tf.placeholder(tf.float32, [None, 784])
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
y = tf.matmul(x, W) + b
y_ = tf.nn.softmax(y)
saver = tf.train.Saver()
params_file = tf.train.latest_checkpoint("./checkpoint_dir")
saver.restore(sess, params_file)
self.output['sess'] = sess
self.output['x'] = x
self.output['y_'] = y_
def execute(self, data, batch_size):
sess = self.output['sess']
x = self.output['x']
y_ = self.output['y_']
ids = []
imgs = []
for i in range(batch_size):
json_input = json.load(data[i])
data_id = json_input['appid']
img_data = json_input['img'].decode('base64')
im = Image.open(StringIO.StringIO(img_data)).resize((28, 28)).convert('L')
im = np.array(im)
im = im.reshape(784)
im = im.astype(np.float32)
im = np.multiply(im, 1.0 / 255.0)
imgs.append(im)
ids.append(data_id)
imgs = np.array(imgs)
print(imgs.shape)
predict = sess.run(y_, feed_dict={x: imgs})
ret = []
for i in range(batch_size):
ret_val = np.array_str( | np.argmax(predict[i]) | numpy.argmax |
#!/usr/bin/env python
"""
Vector Forward Mode
"""
import numpy as npy
import numpy
import instant
class adouble:
"""Class: Algorithmic differentiation"""
def __init__(self, *taylor_coeffs):
"""Constructor takes a list, array, tuple and variable lenght input"""
if not npy.isscalar(taylor_coeffs[0]):
taylor_coeffs = npy.array(taylor_coeffs[0],dtype=float)
self.tc = npy.array(taylor_coeffs,dtype=float)
self.off = 0
self.shp = | npy.shape(self.tc) | numpy.shape |
from __future__ import division
from typing import List, Optional
import numpy as np
import matplotlib.pyplot as plt
import random
import cv2
from PIL import Image, ImageDraw, ImageFont
import pickle
from pathlib import Path
import scipy.signal as ssig
import scipy.stats as sstat
import math
def sample_weighted(p_dict):
ps = list(p_dict.keys())
return p_dict[np.random.choice(ps, p=ps)]
def move_bb(bbs, t):
"""
Translate the bounding-boxes in by t_x,t_y.
BB : 2x4xn
T : 2-long np.array
"""
return bbs + t[:, None, None]
def crop_safe(arr, rect, bbs=[], pad=0):
"""
ARR : arr to crop
RECT: (x,y,w,h) : area to crop to
BBS : nx4 xywh format bounding-boxes
PAD : percentage to pad
Does safe cropping. Returns the cropped rectangle and
the adjusted bounding-boxes
"""
rect = np.array(rect)
rect[:2] -= pad
rect[2:] += 2*pad
x1, y1 = max(0, rect[0]), max(0, rect[1])
x2, y2 = [min(arr.shape[0], rect[0]+rect[2]),
min(arr.shape[1], rect[1]+rect[3])]
arr = arr[y1:y2, x1:x2]
if len(bbs) > 0:
for i in range(len(bbs)):
bbs[i, 0] -= x1
bbs[i, 1] -= y1
return arr, bbs
else:
return arr
class BaselineState(object):
A = [0.50, 0.05]
def __init__(self, a) -> None:
self.a = a
def curve(self, x):
return self.a*x**2
def differential(self, x):
return 2*self.a*x
@staticmethod
def get_sample():
"""
Returns the functions for the curve and differential for a and b
"""
sgn = 1.0
if np.random.rand() < 0.5:
sgn = -1
a = BaselineState.A[1]*np.random.randn() + sgn*BaselineState.A[0]
return BaselineState(a)
class RenderFont(object):
"""
Outputs a rasterized font sample.
Output is a binary mask matrix cropped closesly with the font.
Also, outputs ground-truth bounding boxes and text string
"""
def __init__(self, font_dir: Path, font_model_path: Path, text_path: Path):
# distribution over the type of text:
# whether to get a single word, paragraph or a line:
self.p_text = {1.0: 'WORD',
0.0: 'LINE',
0.0: 'PARA'}
# TEXT PLACEMENT PARAMETERS:
self.f_shrink = 0.90
self.max_shrink_trials = 5 # 0.9^5 ~= 0.6
# the minimum number of characters that should fit in a mask
# to define the maximum font height.
self.min_nchar = 2
self.min_font_h = 48 # px : 0.6*12 ~ 7px <= actual minimum height
self.max_font_h = 320 # px
self.p_flat = 0.10
# curved baseline:
self.p_curved = 1.0
self.baselinestate = BaselineState.get_sample()
# text-source : gets english text:
self.text_source = TextSource(min_nchar=self.min_nchar,
fn=text_path)
# get font-state object:
self.font_state = FontState(font_dir, font_model_path)
def render_multiline(self, font: ImageFont.FreeTypeFont, text):
"""
renders multiline TEXT on the pygame surface SURF with the
font style FONT.
A new line in text is denoted by \n, no other characters are
escaped. Other forms of white-spaces should be converted to space.
returns the updated surface, words and the character bounding boxes.
"""
# get the number of lines
lines = text.split('\n')
line_max_length = lines[np.argmax([len(l) for l in lines])]
LINE_W, LINE_H = font.getsize(line_max_length)
fsize = (round(2.0*LINE_W), round(1.25*LINE_H*len(lines)))
image = Image.new('L', fsize, color='black')
draw = ImageDraw.Draw(image)
char_bb = []
space_w = font.getsize('O')[0]
x, y = 0, 0
for line in lines:
x = 0 # carriage-return
for ch in line: # render each character
if ch.isspace(): # just shift
x += space_w
else:
# render the character
draw.text((x, y), ch, fill='white', font=font)
ch_size = font.getsize(ch)
char_bb.append((x, y, ch_size[0], ch_size[1]))
x += ch_size[0]
y += LINE_H # line-feed
crop_box_x = min([box[0] for box in char_bb])
crop_box_y = min([box[1] for box in char_bb])
crop_box_w = max([box[0]+box[2] for box in char_bb])
crop_box_h = max([box[1]+box[3] for box in char_bb])
crop_box = (crop_box_x, crop_box_y, crop_box_w, crop_box_h)
# debug = image.convert('RGB')
# draw = ImageDraw.Draw(debug)
# for (x, y, w, h) in char_bb:
# draw.rectangle((x, y, x+w, y+h), outline=(255, 0, 0))
# draw.rectangle(crop_box, outline=(0, 255, 0))
# debug.show()
words = ' '.join(text.split())
image = np.array(image.crop(crop_box))
char_bb = np.array(char_bb)
return image, words, char_bb
def render_curved(self, font: ImageFont.FreeTypeFont, word_text): # add lang
"""
use curved baseline for rendering word
"""
def draw_char(font: ImageFont.FreeTypeFont, ch: str, rotation: float):
offsetx, offsety, w, h = list(font.getbbox(ch))
ch_image = Image.new('RGBA', (w, h), (0, 0, 0, 0))
draw = ImageDraw.Draw(ch_image)
draw.text((0, 0), ch, font=font, fill=(255, 255, 255, 255))
ch_image = ch_image.crop((offsetx, offsety, w, h))
ch_image = ch_image.rotate(rotation, Image.BICUBIC, expand=True)
return ch_image
wl = len(word_text)
isword = len(word_text.split()) == 1
if not isword or wl > 10 or np.random.rand() > self.p_curved:
return self.render_multiline(font, word_text)
word_bound = font.getbbox(word_text)
fsize = (round(2.0*word_bound[2]), round(3*word_bound[3]))
image = Image.new('L', fsize, color='black')
# baseline state
mid_idx = wl//2
BS = BaselineState.get_sample()
curve = [BS.curve(i-mid_idx) for i in range(wl)]
curve[mid_idx] = -np.sum(curve) / (wl-1)
rots = [math.degrees(math.atan(BS.differential(i-mid_idx)/(font.size/2)))
for i in range(wl)]
# pillow
size = image.size
ch_image = draw_char(font, word_text[mid_idx], rots[mid_idx])
x = int((size[0] - ch_image.size[0]) / 2)
y = int((size[1] - ch_image.size[1]) / 2 - curve[mid_idx])
image.paste(ch_image, (x, y), mask=ch_image)
mid_ch_bb = (x, y, ch_image.size[0], ch_image.size[1])
char_bb = []
last_bb = mid_ch_bb
for i in range(wl):
# skip the middle character
if i == mid_idx:
last_bb = mid_ch_bb
char_bb.append(mid_ch_bb)
continue
elif i < mid_idx: # left-chars
i = mid_idx-1-i
elif i > mid_idx: # right-chars begin
pass
ch = word_text[i]
# draw a single character to a separate image
ch_bb = list(font.getbbox(ch))
ch_image = draw_char(font, ch, rots[i])
if i < mid_idx:
x = last_bb[0] - ch_bb[2]
elif i >= mid_idx:
x = last_bb[0] + last_bb[2]
y = int(last_bb[1] + 2 + curve[i])
image.paste(ch_image, (x, y), mask=ch_image)
ch_bb[0] = x
ch_bb[1] = y
last_bb = (x, y, ch_image.size[0], ch_image.size[1])
char_bb.append(last_bb)
crop_box_x = min([box[0] for box in char_bb])
crop_box_y = min([box[1] for box in char_bb])
crop_box_w = max([box[0]+box[2] for box in char_bb])
crop_box_h = max([box[1]+box[3] for box in char_bb])
crop_box = (crop_box_x, crop_box_y, crop_box_w, crop_box_h)
# debug = image.convert('RGB')
# draw = ImageDraw.Draw(debug)
# for (x, y, w, h) in char_bb:
# draw.rectangle((x, y, x+w, y+h), outline=(255, 0, 0))
# draw.rectangle(crop_box, outline=(0, 255, 0))
# debug.show()
# exit(0)
word_image = np.array(image.crop(crop_box))
char_bb = np.array(char_bb)
# update box coordinates after cropping
char_bb[:, 0] = char_bb[:, 0] - crop_box_x
char_bb[:, 1] = char_bb[:, 1] - crop_box_y
# plt.imshow(word_image)
# plt.show()
# exit()
return word_image, word_text, char_bb
def get_nline_nchar(self, mask_size, font_height, font_width):
"""
Returns the maximum number of lines and characters which can fit
in the MASK_SIZED image.
"""
H, W = mask_size
nline = int(np.ceil(H/(2*font_height)))
nchar = int(np.floor(W/font_width))
return nline, nchar
def place_text(self, text_arrs: List[np.ndarray], back_arr, bbs: List[np.ndarray]):
areas = [-np.prod(ta.shape) for ta in text_arrs]
order = np.argsort(areas)
locs = [None for i in range(len(text_arrs))]
out_arr = np.zeros_like(back_arr)
for i in order:
ba = np.clip(back_arr.copy().astype(np.float), 0, 255)
ta = np.clip(text_arrs[i].copy().astype(np.float), 0, 255)
ba[ba > 127] = 1e8
intersect = ssig.fftconvolve(ba, ta[:: -1, :: -1], mode='valid')
safemask = intersect < 1e8
if not np.any(safemask): # no collision-free position:
print("COLLISION!!!")
# warn("COLLISION!!!")
return back_arr, locs[: i], bbs[: i], order[: i]
minloc = np.transpose(np.nonzero(safemask))
loc = minloc[ | np.random.choice(minloc.shape[0]) | numpy.random.choice |
"""Test partial_transpose."""
import cvxpy
import numpy as np
from cvxpy.atoms.affine.vstack import Vstack
from toqito.channels import partial_transpose
from toqito.states import bell
def test_partial_transpose_bipartite():
"""Partial transpose of bipartite systems."""
rho = np.arange(16).reshape(4, 4)
# Partial transpose of first subsystem:
res = partial_transpose(rho, [1], [2, 2])
expected_res = np.array([[0, 1, 8, 9], [4, 5, 12, 13], [2, 3, 10, 11], [6, 7, 14, 15]])
bool_mat = np.isclose(expected_res, res)
np.testing.assert_equal(np.all(bool_mat), True)
# Partial transpose of second subsystem:
res = partial_transpose(rho, [2], [2, 2])
expected_res = np.array([[0, 4, 2, 6], [1, 5, 3, 7], [8, 12, 10, 14], [9, 13, 11, 15]])
bool_mat = np.isclose(expected_res, res)
np.testing.assert_equal(np.all(bool_mat), True)
# Full transpose:
res = partial_transpose(rho, [1, 2], [2, 2])
expected_res = np.array([[0, 4, 8, 12], [1, 5, 9, 13], [2, 6, 10, 14], [3, 7, 11, 15]])
bool_mat = np.isclose(expected_res, res)
np.testing.assert_equal(np.all(bool_mat), True)
def test_partial_transpose():
"""
Default partial_transpose.
By default, the partial_transpose function performs the transposition
on the second subsystem.
"""
test_input_mat = np.arange(1, 17).reshape(4, 4)
expected_res = np.array([[1, 5, 3, 7], [2, 6, 4, 8], [9, 13, 11, 15], [10, 14, 12, 16]])
res = partial_transpose(test_input_mat)
bool_mat = | np.isclose(expected_res, res) | numpy.isclose |
from __future__ import print_function
import numpy as np
import os
import pickle as pk
import pyfftw
from lensit.sims.sims_generic import hash_check
from lensit.misc.misc_utils import npy_hash, Freq
from lensit.misc.rfft2_utils import udgrade_rfft2, supersample
from lensit.pbs import pbs
class ell_mat:
"""Library helping with flat-sky patch discretization and harmonic mode structure.
This handles Fourier mode structure on the flat sky, at the given resolution and size of
specified rectangular box.
Args:
lib_dir: various things might be cached there
(unlens *cache* is set to 0, in which case only a hashdict is put there at instantiation)
shape(2-tuple): pair of int defining the number of pixels on each side of the box
lsides(2-tuple): physical size (in radians) of the box sides
cache(optional): if non-zero, a bunch of matrices might be cached to speed up some calculations.
"""
def __init__(self, lib_dir, shape, lsides, cache=1):
assert len(shape) == 2 and len(lsides) == 2
assert shape[0] % 2 == 0 and shape[1] % 2 == 0
assert shape[0] < 2 ** 16 and shape[1] < 2 ** 16
self.shape = tuple(shape)
self.rshape = (shape[0], shape[1] // 2 + 1)
self.lsides = tuple(lsides)
self.lib_dir = lib_dir
self.mmap_mode = None
self.cache=cache
fn_hash = os.path.join(lib_dir, "ellmat_hash.pk")
if pbs.rank == 0 and self.cache > 0:
if not os.path.exists(lib_dir): os.makedirs(lib_dir)
if not os.path.exists(fn_hash):
pk.dump(self.hash_dict(), open(fn_hash, 'wb'), protocol=2)
pbs.barrier()
if self.cache > 0:
hash_check(pk.load(open(fn_hash, 'rb')), self.hash_dict())
if pbs.rank == 0 and self.cache > 0 and not os.path.exists(os.path.join(self.lib_dir, 'ellmat.npy')):
print('ell_mat:caching ells in ' + os.path.join(self.lib_dir, 'ellmat.npy'))
np.save(os.path.join(self.lib_dir, 'ellmat.npy'), self._build_ellmat())
pbs.barrier()
self.ellmax = int(self._get_ellmax())
self._ell_counts = self._build_ell_counts()
self._nz_counts = self._ell_counts.nonzero()
def __eq__(self, other):
return self.shape == other.shape and self.lsides == self.lsides
def _build_ellmat(self):
kmin = 2. * np.pi / np.array(self.lsides)
ky2 = Freq(np.arange(self.shape[0]), self.shape[0]) ** 2 * kmin[0] ** 2
kx2 = Freq(np.arange(self.rshape[1]), self.shape[1]) ** 2 * kmin[1] ** 2
ones = np.ones(np.max(self.shape))
return self.k2ell(np.sqrt(np.outer(ky2, ones[0:self.rshape[1]]) + np.outer(ones[0:self.rshape[0]], kx2)))
def hash_dict(self):
return {'shape': self.shape, 'lsides': self.lsides}
@staticmethod
def k2ell(k):
r"""Mapping of 2d-frequency :math:`k` to multipole :math:`\ell`
:math:`\ell = \rm{int}\left(|k| - \frac 12 \right)`
"""
ret = np.uint16(np.round(k - 0.5) + 0.5 * ((k - 0.5) < 0))
return ret
def __call__(self, *args, **kwargs):
return self.get_ellmat(*args, **kwargs)
def __getitem__(self, item):
return self.get_ellmat()[item]
def get_pixwinmat(self):
r"""Pixel window function rfft array :math:`\sin(k_x l_{\rm cell, x} / 2) \sin (k_y l_{\rm cell, y} / 2 )`
"""
ky = (np.pi/self.shape[0]) * Freq(np.arange(self.shape[0]), self.shape[0])
ky[self.shape[0] // 2:] *= -1.
kx = (np.pi/self.shape[1]) * Freq(np.arange(self.rshape[1]), self.shape[1])
rety = np.sin(ky)
rety[1:] /= ky[1:];rety[0] = 1.
retx = np.sin(kx)
retx[1:] /= kx[1:];retx[0] = 1.
return np.outer(rety,retx)
def get_ellmat(self, ellmax=None):
r"""Returns the matrix containing the multipole ell assigned to 2d-frequency :math:`k = (k_x,k_y)`
"""
if self.cache == 0:
ret = self._build_ellmat()
return ret if ellmax is None else ret[np.where(ret <= ellmax)]
if ellmax is None:
return np.load(os.path.join(self.lib_dir, 'ellmat.npy'), mmap_mode=self.mmap_mode)
else:
fname = os.path.join(self.lib_dir, 'ellmat_ellmax%s.npy' % ellmax)
if os.path.exists(fname): return np.load(fname, mmap_mode=self.mmap_mode)
if pbs.rank == 0:
print('ell_mat:caching ells in ' + fname)
np.save(fname, self.get_ellmat()[np.where(self() <= ellmax)])
pbs.barrier()
return np.load(fname, mmap_mode=self.mmap_mode)
def get_phasemat(self, ellmax=None):
r"""Returns the rfft array containing the phase :math:`\phi` where 2d-frequencies are :math:`k = |k| e^{i \phi}`
"""
if self.cache == 0:
ret = np.arctan2(self.get_ky_mat(), self.get_kx_mat())
return ret if ellmax is None else ret[np.where(self() <= ellmax)]
if ellmax is None:
fname = os.path.join(self.lib_dir, 'phasemat.npy')
if os.path.exists(fname): return np.load(fname, mmap_mode=self.mmap_mode)
if not os.path.exists(fname) and pbs.rank == 0:
print('ell_mat:caching phases in '+ fname)
np.save(fname, np.arctan2(self.get_ky_mat(), self.get_kx_mat()))
pbs.barrier()
return np.load(fname, mmap_mode=self.mmap_mode)
else:
fname = os.path.join(self.lib_dir, 'phase_ellmax%s.npy' % ellmax)
if not os.path.exists(fname) and pbs.rank == 0:
print('ell_mat:caching phases in '+ fname)
np.save(fname, np.arctan2(self.get_ky_mat(), self.get_kx_mat())[np.where(self.get_ellmat() <= ellmax)])
pbs.barrier()
return np.load(fname, mmap_mode=self.mmap_mode)
def get_e2iphi_mat(self, cache_only=False):
r"""Returns the matrix containing the phase :math:`e^{2 i \phi}`
"""
if self.cache == 0:
return np.exp(2j * np.arctan2(self.get_ky_mat(), self.get_kx_mat()))
fname = os.path.join(self.lib_dir, 'e2iphimat.npy')
if os.path.exists(fname):
return None if cache_only else np.load(fname, mmap_mode=self.mmap_mode)
if not os.path.exists(fname) and pbs.rank == 0:
print('ell_mat:caching e2iphi in ' + fname)
np.save(fname, np.exp(2j * np.arctan2(self.get_ky_mat(), self.get_kx_mat())))
pbs.barrier()
return None if cache_only else np.load(fname, mmap_mode=self.mmap_mode)
def degrade(self, LDshape, lib_dir=None):
"""Returns an *ell_mat* instance on the same physical flat-sky patch but a degraded sampling resolution
"""
if np.all(LDshape >= self.shape): return self
if lib_dir is None:
lib_dir = os.path.join(self.lib_dir, 'degraded%sx%s' % (LDshape[0], LDshape[1]))
return ell_mat(lib_dir, LDshape, self.lsides, cache=self.cache)
def get_cossin_2iphi_mat(self):
"""
Returns:
:math:`\cos(2i\phi), \sin(2i\phi)` as rfft arrays
"""
e2iphi = self.get_e2iphi_mat()
return e2iphi.real, e2iphi.imag
def _get_ellmax(self):
r""" Max. ell present in the grid
"""
return np.max(self.get_ellmat())
def _build_ell_counts(self):
counts = np.bincount(self.get_ellmat()[:, 1:self.rshape[1] - 1].flatten(), minlength=self.ellmax + 1)
s_counts = np.bincount(self.get_ellmat()[0:self.shape[0] // 2 + 1, [-1, 0]].flatten())
counts[0:len(s_counts)] += s_counts
return counts
def _get_ellcounts(self):
r"""Number of non-redundant entries in freq map. for each ell, in the rfftmap.
Corresponds roughly to :math:`\ell + \frac 1/2`.
"""
return self._ell_counts
def get_Nell(self):
"""Mode number counts on the flat-sky patch.
Goes roughly like :math:`2\ell + 1`
"""
Nell = 2 * self._get_ellcounts()
for ell in self.get_ellmat()[self.rfft2_reals()]:
Nell[ell] -= 1
return Nell
def get_nonzero_ellcounts(self):
return self._nz_counts
def map2cl(self, m, m2=None):
r"""Returns s pseudo-:math:`C_\ell` estimate from a map.
Returns a cross-:math:`C_\ell` if m2 is set. Must have compatible shape.
"""
assert m.shape == self.shape, m.shape
if m2 is not None:
assert m2.shape == self.shape, m2.shape
return self._rfft2cl(np.fft.rfft2(m), rfftmap2=np.fft.rfft2(m2))
return self._rfft2cl(np.fft.rfft2(m))
def _rfft2cl(self, rfftmap, rfftmap2=None):
"""Returns a :math:`C_\ell` estimate from a rfftmap.
(e.g. np.fft.rfft2(sim) where sim is the output of this library)
Must have the same shape then self.rshape
"""
assert rfftmap.shape == self.rshape, rfftmap.shape
if rfftmap2 is not None: assert rfftmap2.shape == self.rshape, rfftmap2.shape
weights = rfftmap.real ** 2 + rfftmap.imag ** 2 if rfftmap2 is None else (rfftmap * np.conjugate(rfftmap2)).real
Cl = np.bincount(self.get_ellmat()[:, 1:self.rshape[1] - 1].flatten(),
weights=weights[:, 1:self.rshape[1] - 1].flatten(), minlength=self.ellmax + 1)
Cl += np.bincount(self.get_ellmat()[0:self.shape[0] // 2 + 1, [-1, 0]].flatten(),
weights=weights[0:self.shape[0] // 2 + 1, [-1, 0]].flatten(), minlength=self.ellmax + 1)
Cl[self._nz_counts] *= (np.prod(self.lsides) / np.prod(self.shape) ** 2) / self._ell_counts[self._nz_counts]
return Cl
def bin_inell(self, rfftmap):
"""Bin in a rfftmap according to multipole :math:`\ell`
Input must have the same shape then self.rshape
"""
assert rfftmap.shape == self.rshape, rfftmap.shape
weights = rfftmap
Cl = np.bincount(self.get_ellmat()[:, 1:self.rshape[1] - 1].flatten(),
weights=weights[:, 1:self.rshape[1] - 1].flatten(), minlength=self.ellmax + 1)
Cl += np.bincount(self.get_ellmat()[0:self.shape[0] // 2 + 1, [-1, 0]].flatten(),
weights=weights[0:self.shape[0] // 2 + 1, [-1, 0]].flatten(), minlength=self.ellmax + 1)
Cl[self._nz_counts] /= self._ell_counts[self._nz_counts]
return Cl
def get_kx_mat(self):
kx_min = (2. * np.pi) / self.lsides[1]
kx = kx_min * Freq(np.arange(self.rshape[1]), self.shape[1])
return np.outer(np.ones(self.shape[0]), kx)
def get_ky_mat(self):
ky_min = (2. * np.pi) / self.lsides[0]
ky = ky_min * Freq(np.arange(self.shape[0]), self.shape[0])
ky[self.shape[0] // 2:] *= -1.
return np.outer(ky, np.ones(self.rshape[1]))
def get_ikx_mat(self):
return 1j * self.get_kx_mat()
def get_iky_mat(self):
return 1j * self.get_ky_mat()
def get_unique_ells(self, return_index=False, return_inverse=False, return_counts=False):
"""Returns list of multipoles :math:`\ell` present in the flat-sky patch
"""
return np.unique(self.get_ellmat(),
return_index=return_index, return_inverse=return_inverse, return_counts=return_counts)
def rfftmap2alm(self, rfftmap, filt_func=lambda ell: True):
"""Turns a rfft map to ffs_alm array.
This performs the filtering defined by the instance together with the normalization
"""
cond = filt_func(np.arange(self.ellmax + 1))
return rfftmap[cond[self.get_ellmat()]] * np.sqrt(np.prod(self.lsides)) / np.prod(self.shape)
def alm2rfftmap(self, alm, filt_func=lambda ell: True):
"""Returns a ffs_alm array from a rfftmap.
Pseudo-inverse to *fftmap2alm*
"""
cond = filt_func(np.arange(self.ellmax + 1))
ret = np.zeros(self.rshape, dtype=complex)
ret[cond[self.get_ellmat()]] = alm * np.prod(self.shape) / np.sqrt(np.prod(self.lsides))
return ret
def rfft2_reals(self):
"""Pure reals modes in 2d rfft according to patch specifics
"""
N0, N1 = self.shape
fx = [0]
fy = [0]
if N1 % 2 == 0:
fx.append(0)
fy.append(N1 // 2)
if N0 % 2 == 0:
fx.append(N0 // 2)
fy.append(0)
if N1 % 2 == 0 and N0 % 2 == 0:
fx.append(N0 // 2)
fy.append(N1 // 2)
return np.array(fx), np.array(fy)
class ffs_alm(object):
"""Library to facilitate operations on flat-sky alms in the ffs scheme.
Methods includes alm2map and map2alm, among other things.
The instance contains info on the sky patch size and discretization.
Args:
ellmat: *lensit.ffs_covs.ell_mat.ell_mat* instance carrying flat-sky patch definitions
filt_func(callable, optional): mutlipole filtering. Set this to discard multipoles in map2alm
Defaults to lambda ell : ell > 0
kxfilt_func(callable, optional): filtering on x-component of the 2d-frequencies
kyfilt_func(callable, optional): filtering on y-component of the 2d-frequencies
"""
def __init__(self, ellmat, filt_func=lambda ell: ell > 0, kxfilt_func=None, kyfilt_func=None):
self.ell_mat = ellmat
self.shape = self.ell_mat.shape
self.lsides = self.ell_mat.lsides
self.filt_func = filt_func
self.kxfilt_func = kxfilt_func
self.kyfilt_func = kyfilt_func
self.alm_size = np.count_nonzero(self._cond())
# The mapping ell[i] for i in alm array :
self.reduced_ellmat = lambda: ellmat()[self._cond()]
self.ellmax = np.max(self.reduced_ellmat()) if self.alm_size > 0 else None
self.ellmin = np.min(self.reduced_ellmat()) if self.alm_size > 0 else None
# Some trivial convenience factors :
self.fac_rfft2alm = np.sqrt(np.prod(ellmat.lsides)) / np.prod(self.ell_mat.shape)
self.fac_alm2rfft = 1. / self.fac_rfft2alm
self.__ellcounts = None
def _cond(self):
ret = self.filt_func(self.ell_mat())
if self.kxfilt_func is not None:
ret &= self.kxfilt_func(self.ell_mat.get_kx_mat())
if self.kyfilt_func is not None:
ret &= self.kyfilt_func(self.ell_mat.get_ky_mat())
return ret
def __eq__(self, lib_alm):
if not np.all(self.ell_mat.lsides == lib_alm.ell_mat.lsides):
return False
if not np.all(self.ell_mat.shape == lib_alm.ell_mat.shape):
return False
ellmax = max(self.ellmax, lib_alm.ellmax)
if not np.all(self.filt_func(np.arange(ellmax + 1)) == lib_alm.filt_func(np.arange(ellmax + 1))):
return False
kxf = self.kxfilt_func if self.kxfilt_func is not None else lambda kx : np.ones_like(kx, dtype = bool)
_kxf = lib_alm.kxfilt_func if lib_alm.kxfilt_func is not None else lambda kx: np.ones_like(kx, dtype=bool)
if not np.all(kxf(np.arange(-ellmax,ellmax + 1)) == _kxf(np.arange(-ellmax,ellmax + 1))):
return False
kyf = self.kyfilt_func if self.kyfilt_func is not None else lambda ky : np.ones_like(ky, dtype = bool)
_kyf = lib_alm.kyfilt_func if lib_alm.kyfilt_func is not None else lambda ky: np.ones_like(ky, dtype=bool)
if not np.all(kyf(np.arange(-ellmax,ellmax + 1)) == _kyf(np.arange(-ellmax,ellmax + 1))):
return False
return True
def iseq(self, lib_alm, allow_shape=False):
if not allow_shape: return self == lib_alm
# We allow differences in resolution provided the filtering is the scheme
# (ordering should then be the same as well)
if not np.all(self.ell_mat.lsides == lib_alm.ell_mat.lsides):
return False
if not self.alm_size == lib_alm.alm_size:
return False
ellmax = max(self.ellmax, lib_alm.ellmax)
if not np.all(self.filt_func(np.arange(ellmax + 1)) == lib_alm.filt_func( | np.arange(ellmax + 1) | numpy.arange |
import sys
import numpy as np
import scipy.ndimage
import matplotlib.pyplot as plt
import soundfile
# Test of pitch-shift quality without PVC
if __name__ == "__main__":
block_size = 4096
n_blocks = 4
FILT_SIZE = 8
if len(sys.argv) < 5:
print(
"Usage: {} <in_filename> <out_filename> <length_mult> <pitch_mult> [block_size={}] [n_blocks={}]".format(
sys.argv[0], block_size, n_blocks
)
)
sys.exit()
in_filename = sys.argv[1]
out_filename = sys.argv[2]
length_mult = float(sys.argv[3])
pitch_mult = float(sys.argv[4])
if len(sys.argv) >= 6:
block_size = int(sys.argv[5])
if len(sys.argv) >= 7:
n_blocks = int(sys.argv[6])
in_shift = block_size // n_blocks
out_shift = int(in_shift * length_mult)
in_file = soundfile.SoundFile(in_filename)
rate = in_file.samplerate
n_blocks = np.ceil(in_file.frames / in_shift)
out_length = int(n_blocks * out_shift + block_size)
# print("from", in_file.frames, "to", out_length)
out_data = np.zeros((out_length, in_file.channels))
indices = | np.arange(block_size // 2 + 1) | numpy.arange |
# -*- coding: utf-8 -*-
import os
os.environ["MKL_NUM_THREADS"] = "1"
os.environ["NUMEXPR_NUM_THREADS"] = "1"
os.environ["OMP_NUM_THREADS"] = "1"
from os import path, listdir
import numpy as np
np.random.seed(1)
import random
random.seed(1)
import pandas as pd
import timeit
import cv2
from tqdm import tqdm
import sys
sys.setrecursionlimit(10000)
from multiprocessing import Pool
from shapely.geometry.linestring import LineString
from skimage.morphology import skeletonize_3d, square, erosion, dilation, medial_axis
from skimage.measure import label, regionprops, approximate_polygon
from math import hypot, sin, cos, asin, acos, radians
from sklearn.neighbors import KDTree
from shapely.wkt import dumps
# import matplotlib.pyplot as plt
# import seaborn as sns
pred_folders = ['/wdata/test_pred', '/wdata/test_pred_960']
def get_ordered_coords(lbl, l, coords):
res = []
nxt = coords[0]
for i in range(coords.shape[0]):
y, x = coords[i]
cnt = 0
for y0 in range(max(0, y-1), min(1300, y+2)):
for x0 in range(max(0, x-1), min(1300, x+2)):
if lbl[y0, x0] == l:
cnt += 1
if cnt == 2:
nxt = coords[i]
lbl[y, x] = 0
res.append(nxt)
break
while nxt is not None:
y, x = nxt
fl = False
for y0 in range(max(0, y-1), min(1300, y+2)):
for x0 in range(max(0, x-1), min(1300, x+2)):
if lbl[y0, x0] == l:
fl = True
nxt = np.asarray([y0, x0])
lbl[y0, x0] = 0
res.append(nxt)
break
if fl:
break
if not fl:
nxt = None
return np.asarray(res)
def point_hash(x, y):
x_int = int(x)
y_int = int(y)
h = x_int * 10000 + y_int
return h
def pair_hash(p1, p2):
h1 = point_hash(p1[0], p1[1])
h2 = point_hash(p2[0], p2[1])
return np.int64(h1 * 1e8 + h2)
def get_next_point(p1, p2, add_dist):
l = hypot(p1[0] - p2[0], p1[1] - p2[1])
dx = (p2[1] - p1[1]) / l
dy = (p2[0] - p1[0]) / l
x3 = int(round(p1[1] + (l + add_dist) * dx))
y3 = int(round(p1[0] + (l + add_dist) * dy))
if x3 < 0:
x3 = 0
if y3 < 0:
y3 = 0
if x3 > 1299:
x3 = 1299
if y3 > 1299:
y3 = 1299
return np.asarray([y3, x3])
def try_connect(p1, p2, a, max_dist, road_msk, min_prob, msk, roads, r=3):
prob = []
r_id = road_msk[p2[0], p2[1]]
hashes = set([point_hash(p2[1], p2[0])])
l = hypot(p1[0] - p2[0], p1[1] - p2[1])
dx = (p2[1] - p1[1]) / l
dy = (p2[0] - p1[0]) / l
if a != 0:
l = 0
p1 = p2
_a = asin(dy) + a
dy = sin(_a)
_a = acos(dx) + a
dx = cos(_a)
step = 0.5
d = step
while d < max_dist:
x3 = int(round(p1[1] + (l + d) * dx))
y3 = int(round(p1[0] + (l + d) * dy))
if x3 < 0 or y3 < 0 or x3 > 1299 or y3 > 1299:
return None
h = point_hash(x3, y3)
if h not in hashes:
prob.append(msk[y3, x3])
hashes.add(h)
for x0 in range(max(0, x3 - r), min(1299, x3 + r + 1)):
for y0 in range(max(0, y3 - r), min(1299, y3 + r + 1)):
if road_msk[y0, x0] > 0 and road_msk[y0, x0] != r_id:
p3 = np.asarray([y0, x0])
r2_id = road_msk[y0, x0] - 1
t = KDTree(roads[r2_id])
clst = t.query(p3[np.newaxis, :])
if clst[0][0][0] < 10:
p3 = roads[r2_id][clst[1][0][0]]
if np.asarray(prob).mean() > min_prob:
return p3
else:
return None
d += step
return None
def inject_point(road, p):
for i in range(road.shape[0]):
if road[i, 0] == p[0] and road[i, 1] == p[1]:
return road, []
new_road = []
to_add = True
new_hashes = []
for i in range(road.shape[0] - 1):
new_road.append(road[i])
if (to_add and min(road[i, 0], road[i+1, 0]) <= p[0]
and max(road[i, 0], road[i+1, 0]) >= p[0]
and min(road[i, 1], road[i+1, 1]) <= p[1]
and max(road[i, 1], road[i+1, 1]) >= p[1]):
to_add = False
new_road.append(p)
new_hashes.append(pair_hash(p, road[i]))
new_hashes.append(pair_hash(road[i], p))
new_hashes.append(pair_hash(p, road[i+1]))
new_hashes.append(pair_hash(road[i+1], p))
new_road.append(road[-1])
return np.asarray(new_road), new_hashes
def process_file(img_id):
res_rows = []
msks = []
for pred_folder in pred_folders:
msk = cv2.imread(path.join(pred_folder, img_id + '.png'), cv2.IMREAD_UNCHANGED)
msk = msk.max(axis=2)
if msk.shape[0] < 1306:
msk = cv2.resize(msk, (1300, 1300))
msk = np.pad(msk, ((6, 6), (6, 6)), mode='reflect')
else:
msk = msk[6:1306, 6:1306]
msk = np.pad(msk, ((6, 6), (6, 6)), mode='reflect')
msks.append(msk)
msks = np.asarray(msks)
msk = msks.mean(axis=0)
thr = 120
msk2 = 1 * (msk > thr)
msk2 = msk2.astype(np.uint8)
msk2 = dilation(msk2, square(5))
msk2 = erosion(msk2, square(5))
skeleton = skeletonize_3d(msk2)
skeleton = skeleton[6:1306, 6:1306]
lbl0 = label(skeleton)
props0 = regionprops(lbl0)
cnt = 0
crosses = []
for x in range(1300):
for y in range(1300):
if skeleton[y, x] == 1:
if skeleton[max(0, y-1):min(1300, y+2), max(0, x-1):min(1300, x+2)].sum() > 3:
cnt += 1
crss = []
crss.append((x, y))
for y0 in range(max(0, y-1), min(1300, y+2)):
for x0 in range(max(0, x-1), min(1300, x+2)):
if x == x0 and y == y0:
continue
if skeleton[max(0, y0-1):min(1300, y0+2), max(0, x0-1):min(1300, x0+2)].sum() > 3:
crss.append((x0, y0))
crosses.append(crss)
cross_hashes = []
for crss in crosses:
crss_hash = set([])
for x0, y0 in crss:
crss_hash.add(point_hash(x0, y0))
skeleton[y0, x0] = 0
cross_hashes.append(crss_hash)
new_crosses = []
i = 0
while i < len(crosses):
new_hashes = set([])
new_hashes.update(cross_hashes[i])
new_crss = crosses[i][:]
fl = True
while fl:
fl = False
j = i + 1
while j < len(crosses):
if len(new_hashes.intersection(cross_hashes[j])) > 0:
new_hashes.update(cross_hashes[j])
new_crss.extend(crosses[j])
cross_hashes.pop(j)
crosses.pop(j)
fl = True
break
j += 1
mean_p = np.asarray(new_crss).mean(axis=0).astype('int')
if len(new_crss) > 1:
t = KDTree(np.asarray(new_crss))
mean_p = new_crss[t.query(mean_p[np.newaxis, :])[1][0][0]]
new_crosses.append([(mean_p[0], mean_p[1])] + new_crss)
i += 1
crosses = new_crosses
lbl = label(skeleton)
props = regionprops(lbl)
connected_roads = []
connected_crosses = [set([]) for p in props]
for i in range(len(crosses)):
rds = set([])
for j in range(len(crosses[i])):
x, y = crosses[i][j]
for y0 in range(max(0, y-1), min(1300, y+2)):
for x0 in range(max(0, x-1), min(1300, x+2)):
if lbl[y0, x0] > 0:
rds.add(lbl[y0, x0])
connected_crosses[lbl[y0, x0]-1].add(i)
connected_roads.append(rds)
res_roads = []
tot_dist_min = 20
coords_min = 10
for i in range(len(props)):
coords = props[i].coords
crss = list(connected_crosses[i])
tot_dist = props0[lbl0[coords[0][0], coords[0][1]]-1].area
if (tot_dist < tot_dist_min) or (coords.shape[0] < coords_min and len(crss) < 2):
continue
if coords.shape[0] == 1:
coords = np.asarray([coords[0], coords[0]])
else:
coords = get_ordered_coords(lbl, i+1, coords)
for j in range(len(crss)):
x, y = crosses[crss[j]][0]
d1 = abs(coords[0][0] - y) + abs(coords[0][1] - x)
d2 = abs(coords[-1][0] - y) + abs(coords[-1][1] - x)
if d1 < d2:
coords[0][0] = y
coords[0][1] = x
else:
coords[-1][0] = y
coords[-1][1] = x
coords_approx = approximate_polygon(coords, 1.5)
res_roads.append(coords_approx)
hashes = set([])
final_res_roads = []
for r in res_roads:
if r.shape[0] > 2:
final_res_roads.append(r)
for i in range(1, r.shape[0]):
p1 = r[i-1]
p2 = r[i]
h1 = pair_hash(p1, p2)
h2 = pair_hash(p2, p1)
hashes.add(h1)
hashes.add(h2)
for r in res_roads:
if r.shape[0] == 2:
p1 = r[0]
p2 = r[1]
h1 = pair_hash(p1, p2)
h2 = pair_hash(p2, p1)
if not (h1 in hashes or h2 in hashes):
final_res_roads.append(r)
hashes.add(h1)
hashes.add(h2)
end_points = {}
for r in res_roads:
h = point_hash(r[0, 0], r[0, 1])
if not (h in end_points.keys()):
end_points[h] = 0
end_points[h] = end_points[h] + 1
h = point_hash(r[-1, 0], r[-1, 1])
if not (h in end_points.keys()):
end_points[h] = 0
end_points[h] = end_points[h] + 1
road_msk = np.zeros((1300, 1300), dtype=np.int32)
road_msk = road_msk.copy()
thickness = 1
for j in range(len(final_res_roads)):
l = final_res_roads[j]
for i in range(len(l) - 1):
cv2.line(road_msk, (int(l[i, 1]), int(l[i, 0])), (int(l[i+1, 1]), int(l[i+1, 0])), j+1, thickness)
connect_dist = 110
min_prob = 30
angles_to_check = [0, radians(5), radians(-5), radians(10), radians(-10), radians(15), radians(-15)]
angles_to_check += [radians(20), radians(-20), radians(25), radians(-25)]
add_dist = 30
add_dist2 = 6
con_r = 8
for i in range(len(final_res_roads)):
h = point_hash(final_res_roads[i][0, 0], final_res_roads[i][0, 1])
if end_points[h] == 1:
p1 = final_res_roads[i][1]
p2 = final_res_roads[i][0]
p3 = try_connect(p1, p2, 0, connect_dist, road_msk, min_prob, msk, final_res_roads, con_r)
if p3 is not None:
h1 = pair_hash(p2, p3)
h2 = pair_hash(p3, p2)
if not (h1 in hashes or h2 in hashes):
r_id = road_msk[p3[0], p3[1]] - 1
final_res_roads[r_id], new_hashes = inject_point(final_res_roads[r_id], p3)
hashes.update(new_hashes)
tmp_road_msk = np.zeros((1300, 1300), dtype=np.int32)
tmp_road_msk = tmp_road_msk.copy()
cv2.line(tmp_road_msk, (p2[1], p2[0]), (p3[1], p3[0]), i+1, thickness)
road_msk[road_msk == 0] = tmp_road_msk[road_msk == 0]
road_msk = road_msk.copy()
final_res_roads[i] = np.vstack((p3, final_res_roads[i]))
hashes.add(h1)
hashes.add(h2)
end_points[point_hash(p3[0], p3[1])] = 2
h = point_hash(final_res_roads[i][-1, 0], final_res_roads[i][-1, 1])
if end_points[h] == 1:
p1 = final_res_roads[i][-2]
p2 = final_res_roads[i][-1]
p3 = try_connect(p1, p2, 0, connect_dist, road_msk, min_prob, msk, final_res_roads, con_r)
if p3 is not None:
h1 = pair_hash(p2, p3)
h2 = pair_hash(p3, p2)
if not (h1 in hashes or h2 in hashes):
r_id = road_msk[p3[0], p3[1]] - 1
final_res_roads[r_id], new_hashes = inject_point(final_res_roads[r_id], p3)
hashes.update(new_hashes)
tmp_road_msk = np.zeros((1300, 1300), dtype=np.int32)
tmp_road_msk = tmp_road_msk.copy()
cv2.line(tmp_road_msk, (p2[1], p2[0]), (p3[1], p3[0]), i+1, thickness)
road_msk[road_msk == 0] = tmp_road_msk[road_msk == 0]
road_msk = road_msk.copy()
final_res_roads[i] = np.vstack((final_res_roads[i], p3))
hashes.add(h1)
hashes.add(h2)
end_points[point_hash(p3[0], p3[1])] = 2
for i in range(len(final_res_roads)):
h = point_hash(final_res_roads[i][0, 0], final_res_roads[i][0, 1])
if end_points[h] == 1:
p1 = final_res_roads[i][1]
p2 = final_res_roads[i][0]
p3 = None
for a in angles_to_check:
p3 = try_connect(p1, p2, a, connect_dist, road_msk, min_prob, msk, final_res_roads, con_r)
if p3 is not None:
break
if p3 is not None:
h1 = pair_hash(p2, p3)
h2 = pair_hash(p3, p2)
if not (h1 in hashes or h2 in hashes):
r_id = road_msk[p3[0], p3[1]] - 1
final_res_roads[r_id], new_hashes = inject_point(final_res_roads[r_id], p3)
hashes.update(new_hashes)
tmp_road_msk = np.zeros((1300, 1300), dtype=np.int32)
tmp_road_msk = tmp_road_msk.copy()
cv2.line(tmp_road_msk, (p2[1], p2[0]), (p3[1], p3[0]), i+1, thickness)
road_msk[road_msk == 0] = tmp_road_msk[road_msk == 0]
road_msk = road_msk.copy()
final_res_roads[i] = np.vstack((p3, final_res_roads[i]))
hashes.add(h1)
hashes.add(h2)
end_points[point_hash(p3[0], p3[1])] = 2
else:
p3 = get_next_point(p1, p2, add_dist)
if not (p3[0] < 2 or p3[1] < 2 or p3[0] > 1297 or p3[1] > 1297):
p3 = get_next_point(p1, p2, add_dist2)
if (p3[0] != p2[0] or p3[1] != p2[1]) and (road_msk[p3[0], p3[1]] == 0):
h1 = pair_hash(p2, p3)
h2 = pair_hash(p3, p2)
if not (h1 in hashes or h2 in hashes):
final_res_roads[i] = np.vstack((p3, final_res_roads[i]))
hashes.add(h1)
hashes.add(h2)
tmp_road_msk = np.zeros((1300, 1300), dtype=np.int32)
tmp_road_msk = tmp_road_msk.copy()
cv2.line(tmp_road_msk, (p2[1], p2[0]), (p3[1], p3[0]), i+1, thickness)
road_msk[road_msk == 0] = tmp_road_msk[road_msk == 0]
road_msk = road_msk.copy()
end_points[point_hash(p3[0], p3[1])] = 2
h = point_hash(final_res_roads[i][-1, 0], final_res_roads[i][-1, 1])
if end_points[h] == 1:
p1 = final_res_roads[i][-2]
p2 = final_res_roads[i][-1]
p3 = None
for a in angles_to_check:
p3 = try_connect(p1, p2, a, connect_dist, road_msk, min_prob, msk, final_res_roads, con_r)
if p3 is not None:
break
if p3 is not None:
h1 = pair_hash(p2, p3)
h2 = pair_hash(p3, p2)
if not (h1 in hashes or h2 in hashes):
r_id = road_msk[p3[0], p3[1]] - 1
final_res_roads[r_id], new_hashes = inject_point(final_res_roads[r_id], p3)
hashes.update(new_hashes)
tmp_road_msk = np.zeros((1300, 1300), dtype=np.int32)
tmp_road_msk = tmp_road_msk.copy()
cv2.line(tmp_road_msk, (p2[1], p2[0]), (p3[1], p3[0]), i+1, thickness)
road_msk[road_msk == 0] = tmp_road_msk[road_msk == 0]
road_msk = road_msk.copy()
final_res_roads[i] = np.vstack((final_res_roads[i], p3))
hashes.add(h1)
hashes.add(h2)
end_points[point_hash(p3[0], p3[1])] = 2
else:
p3 = get_next_point(p1, p2, add_dist)
if not (p3[0] < 2 or p3[1] < 2 or p3[0] > 1297 or p3[1] > 1297):
p3 = get_next_point(p1, p2, add_dist2)
if (p3[0] != p2[0] or p3[1] != p2[1]) and (road_msk[p3[0], p3[1]] == 0):
h1 = pair_hash(p2, p3)
h2 = pair_hash(p3, p2)
if not (h1 in hashes or h2 in hashes):
final_res_roads[i] = | np.vstack((final_res_roads[i], p3)) | numpy.vstack |
# SVMs for Food Experiment Data
import matplotlib
import numpy as np
import matplotlib.pyplot as pp
import optparse
import unittest
import random
import itertools
from sklearn import decomposition
from sklearn import svm
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import KFold
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from scipy.interpolate import InterpolatedUnivariateSpline
from scipy.ndimage.filters import gaussian_filter1d
import sys
import lib_get_subset as lib_get_subset
import lib_overlapping as lib_overlapping
import matplotlib.pyplot as plt
try:
import cPickle as pkl
def load_pickle(filename):
with open(filename, 'rb') as f:
return pkl.load(f)
except:
import pickle as pkl
def load_pickle(filename):
with open(filename, 'rb') as f:
return pkl.load(f, encoding = 'latin1')
TRIAL_ORDER = [[1, 4, 6, 2, 3, 7, 0, 5, 8],
[0, 3, 6, 2, 5, 7, 1, 4, 8],
[2, 3, 7, 1, 4, 6, 0, 5, 8],
[2, 4, 6, 0, 5, 8, 1, 3, 7],
[0, 5, 6, 1, 4, 7, 2, 3, 8],
[1, 3, 8, 0, 4, 6, 2, 5, 7],
[0, 4, 7, 1, 3, 8, 2, 5, 6],
[2, 3, 8, 0, 4, 6, 1, 5, 7],
[0, 3, 8, 2, 4, 6, 1, 5, 7],
[1, 3, 6, 0, 5, 7, 2, 4, 8],
[0, 5, 7, 1, 3, 8, 2, 4, 6],
[1, 3, 8, 0, 4, 7, 2, 5, 6],
[1, 5, 6, 0, 4, 7, 2, 3, 8],
[1, 5, 8, 2, 4, 6, 0, 3, 7],
[1, 5, 8, 2, 4, 6, 0, 3, 7],
[1, 4, 6, 2, 5, 7, 0, 3, 8],
[0, 4, 6, 2, 5, 8, 1, 3, 7],
[2, 4, 7, 0, 5, 6, 1, 3, 8],
[1, 5, 7, 0, 3, 6, 2, 4, 8],
[2, 5, 7, 0, 4, 8, 1, 3, 6],
[2, 5, 7, 1, 4, 6, 0, 3, 8],
[0, 5, 7, 2, 3, 6, 1, 4, 8],
[2, 4, 8, 0, 5, 6, 1, 3, 7],
[2, 5, 7, 0, 4, 8, 1, 3, 6],
[1, 3, 7, 2, 5, 8, 0, 4, 6],
[2, 3, 8, 1, 5, 7, 0, 4, 6],
[2, 3, 7, 0, 5, 8, 1, 4, 6],
[1, 4, 7, 0, 5, 6, 2, 3, 8],
[2, 5, 8, 1, 3, 6, 0, 4, 7],
[1, 4, 8, 0, 5, 7, 2, 3, 6]]
NUM_TRIAL_SETS = len(TRIAL_ORDER)
def create_dataset(train_type, alignment_type):
R_W1, R_W2, R_W3 = [], [], []
R_CW1, R_CW2, R_CW3 = [], [], []
R_M1, R_M2, R_M3 = [], [], []
for trial_set in range(len(TRIAL_ORDER)):
if trial_set == NUM_TRIAL_SETS: break
directory = "./test/R_"+str(trial_set + 1)
print(directory+"/M_count_"+str(TRIAL_ORDER[trial_set][6])+"_sensor_29.5.pkl")
R_M1.append(load_pickle(directory+"/M_count_"+str(TRIAL_ORDER[trial_set][6])+"_sensor_29.5.pkl"))
R_M2.append(load_pickle(directory+"/M_count_"+str(TRIAL_ORDER[trial_set][7])+"_sensor_29.5.pkl"))
R_M3.append(load_pickle(directory+"/M_count_"+str(TRIAL_ORDER[trial_set][8])+"_sensor_29.5.pkl"))
R_W1.append(load_pickle(directory+"/W_count_"+str(TRIAL_ORDER[trial_set][0])+"_sensor_29.5.pkl"))
R_W2.append(load_pickle(directory+"/W_count_"+str(TRIAL_ORDER[trial_set][1])+"_sensor_29.5.pkl"))
R_W3.append(load_pickle(directory+"/W_count_"+str(TRIAL_ORDER[trial_set][2])+"_sensor_29.5.pkl"))
R_CW1.append(load_pickle(directory+"/CW_count_"+str(TRIAL_ORDER[trial_set][3])+"_sensor_29.5.pkl"))
R_CW2.append(load_pickle(directory+"/CW_count_"+str(TRIAL_ORDER[trial_set][4])+"_sensor_29.5.pkl"))
R_CW3.append(load_pickle(directory+"/CW_count_"+str(TRIAL_ORDER[trial_set][5])+"_sensor_29.5.pkl"))
x_full = R_CW1[0][:, 0]
#match_set_LOW = R_CW3[0][250:1250,2]
#match_set_HIGH = R_W1[0][280:1280,2]
match_set_W = load_pickle("./test/R_1/W_count_"+str(TRIAL_ORDER[0][0])+"_sensor_29.5.pkl")[184:1184,2]
match_set_CW = load_pickle("./test/R_1/CW_count_"+str(TRIAL_ORDER[0][3])+"_sensor_29.5.pkl")[32:1032,2]
match_set_M = load_pickle("./test/R_1/M_count_"+str(TRIAL_ORDER[0][6])+"_sensor_29.5.pkl")[130:1130,2]
print(R_M1[0][:,4])
data_dict = {}
for trial_set in range(NUM_TRIAL_SETS):
if train_type == 'all_active' or train_type == 'noCW_active':
if alignment_type == 'firstsec':
data_dict['trial_set_'+str(trial_set+1)+'_X'] = np.vstack((
lib_get_subset.get_x_matched_set(x_full, match_set_M, R_M1[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_set(x_full, match_set_M, R_M2[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_set(x_full, match_set_M, R_M3[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_set(x_full, match_set_W, R_W1[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_set(x_full, match_set_W, R_W2[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_set(x_full, match_set_W, R_W3[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_set(x_full, match_set_CW, R_CW1[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_set(x_full, match_set_CW, R_CW2[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_set(x_full, match_set_CW, R_CW3[trial_set][:, 1:3], is_heated=True)))
elif alignment_type == 'curvemax':
data_dict['trial_set_'+str(trial_set+1)+'_X'] = np.vstack((
lib_get_subset.get_x_matched_deriv_set(x_full, R_M1[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_deriv_set(x_full, R_M2[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_deriv_set(x_full, R_M3[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_deriv_set(x_full, R_W1[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_deriv_set(x_full, R_W2[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_deriv_set(x_full, R_W3[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_deriv_set(x_full, R_CW1[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_deriv_set(x_full, R_CW2[trial_set][:, 1:3], is_heated=True),
lib_get_subset.get_x_matched_deriv_set(x_full, R_CW3[trial_set][:, 1:3], is_heated=True)))
elif alignment_type == 'force':
data_dict['trial_set_'+str(trial_set+1)+'_X'] = np.vstack((
lib_get_subset.get_x_matched_force_set(x_full, R_M1[trial_set][:, 1:5], is_heated=True),
lib_get_subset.get_x_matched_force_set(x_full, R_M2[trial_set][:, 1:5], is_heated=True),
lib_get_subset.get_x_matched_force_set(x_full, R_M3[trial_set][:, 1:5], is_heated=True),
lib_get_subset.get_x_matched_force_set(x_full, R_W1[trial_set][:, 1:5], is_heated=True),
lib_get_subset.get_x_matched_force_set(x_full, R_W2[trial_set][:, 1:5], is_heated=True),
lib_get_subset.get_x_matched_force_set(x_full, R_W3[trial_set][:, 1:5], is_heated=True),
lib_get_subset.get_x_matched_force_set(x_full, R_CW1[trial_set][:, 1:5], is_heated=True),
lib_get_subset.get_x_matched_force_set(x_full, R_CW2[trial_set][:, 1:5], is_heated=True),
lib_get_subset.get_x_matched_force_set(x_full, R_CW3[trial_set][:, 1:5], is_heated=True)))
elif train_type == 'all_active_passive' or train_type == 'noCW_active_passive':
if alignment_type == 'firstsec':
data_dict['trial_set_'+str(trial_set+1)+'_X'] = np.vstack((
lib_get_subset.get_x_matched_set(x_full, match_set_M, R_M1[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_set(x_full, match_set_M, R_M1[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_set(x_full, match_set_M, R_M2[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_set(x_full, match_set_M, R_M2[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_set(x_full, match_set_M, R_M3[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_set(x_full, match_set_M, R_M3[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_set(x_full, match_set_W, R_W1[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_set(x_full, match_set_W, R_W1[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_set(x_full, match_set_W, R_W2[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_set(x_full, match_set_W, R_W2[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_set(x_full, match_set_W, R_W3[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_set(x_full, match_set_W, R_W3[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_set(x_full, match_set_CW, R_CW1[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_set(x_full, match_set_CW, R_CW1[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_set(x_full, match_set_CW, R_CW2[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_set(x_full, match_set_CW, R_CW2[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_set(x_full, match_set_CW, R_CW3[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_set(x_full, match_set_CW, R_CW3[trial_set][:, 1:3], is_heated=False)))
elif alignment_type == 'curvemax':
data_dict['trial_set_'+str(trial_set+1)+'_X'] = np.vstack((
lib_get_subset.get_x_matched_deriv_set(x_full, R_M1[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_deriv_set(x_full, R_M1[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_deriv_set(x_full, R_M2[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_deriv_set(x_full, R_M2[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_deriv_set(x_full, R_M3[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_deriv_set(x_full, R_M3[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_deriv_set(x_full, R_W1[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_deriv_set(x_full, R_W1[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_deriv_set(x_full, R_W2[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_deriv_set(x_full, R_W2[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_deriv_set(x_full, R_W3[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_deriv_set(x_full, R_W3[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_deriv_set(x_full, R_CW1[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_deriv_set(x_full, R_CW1[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_deriv_set(x_full, R_CW2[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_deriv_set(x_full, R_CW2[trial_set][:, 1:3], is_heated=False),
lib_get_subset.get_x_matched_deriv_set(x_full, R_CW3[trial_set][:, 1:3], is_heated=True)+lib_get_subset.get_x_matched_deriv_set(x_full, R_CW3[trial_set][:, 1:3], is_heated=False)))
#print(data_dict['trial_set_1_X'].shape)
#print(data_dict['trial_set_'+str(trial_set+1)+'_X'].shape)
#data_dict['trial_set_'+str(trial_set+1)+'_y'] = np.array([1, 1, 1, 0, 0, 0, 0, 0, 0])
data_dict['trial_set_'+str(trial_set+1)+'_y'] = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2])
#print(data_dict['trial_set_'+str(trial_set+1)+'_y'].shape)
if train_type == 'all_active':# or train_type == 'all_active_passive':
#data_dict = lib_overlapping.get_most_overlapping(x_full, data_dict, num_pairs = 10)
#data_dict = lib_overlapping.get_overlapping_reference(x_full, data_dict, num_referenced = 20)
data_dict = lib_overlapping.get_meanstd_overlapping2(data_dict) #x_full,
cross_val_dict = {}
for trial_set in range(NUM_TRIAL_SETS):
X_train = []
y_train = []
for other_trial_set in range(NUM_TRIAL_SETS):
if other_trial_set != trial_set:
if train_type == 'all_active' or train_type == 'all_active_passive':
try:
X_train = np.concatenate((X_train, data_dict['trial_set_'+str(other_trial_set+1)+'_X']), axis = 0)
except:
X_train = data_dict['trial_set_'+str(other_trial_set+1)+'_X']
try:
y_train = np.concatenate((y_train, data_dict['trial_set_'+str(other_trial_set+1)+'_y']), axis = 0)
except:
y_train = data_dict['trial_set_'+str(other_trial_set+1)+'_y']
elif train_type == 'noCW_active' or train_type == 'noCW_active_passive':
try:
X_train = np.concatenate((X_train, data_dict['trial_set_' + str(other_trial_set + 1) + '_X'][0:6, :]), axis=0)
except:
X_train = data_dict['trial_set_' + str(other_trial_set + 1) + '_X'][0:6, :]
try:
y_train = np.concatenate((y_train, data_dict['trial_set_' + str(other_trial_set + 1) + '_y'][0:6]), axis=0)
except:
y_train = data_dict['trial_set_' + str(other_trial_set + 1) + '_y'][0:6]
cross_val_dict['fold'+str(trial_set+1)+'_X_train'] = X_train #shape is (8x9) x (1000)
cross_val_dict['fold'+str(trial_set+1)+'_y_train'] = y_train #shape is (8x9)
cross_val_dict['fold'+str(trial_set+1)+'_X_test'] = data_dict['trial_set_'+str(trial_set+1)+'_X'] #shape is (1x9) x (1000)
cross_val_dict['fold'+str(trial_set+1)+'_y_test'] = data_dict['trial_set_'+str(trial_set+1)+'_y'] #shape is (1x9)
print("created dataset")
return cross_val_dict, data_dict
def run_crossvalidation_all(cross_val_dict, trial_set, svm_type):
#print("cross val on trial set", trial_set)
scores_list = []
X_train = cross_val_dict['fold'+str(trial_set+1)+'_X_train']
y_train = cross_val_dict['fold'+str(trial_set+1)+'_y_train']
X_test = cross_val_dict['fold'+str(trial_set+1)+'_X_test']
y_test = cross_val_dict['fold'+str(trial_set+1)+'_y_test']
#print(np.shape(X_train), np.shape(X_test), np.shape(y_train), np.shape(y_test))
#print(X_test, y_test)
#print(X_train, y_train)
svc = svm.SVC(kernel=svm_type)
#svc = svm.SVC(kernel='rbf')
#svc = svm.SVC(kernel='poly', degree=3)
clf = svc.fit(X_train, y_train)
preds = svc.predict(X_test)
#print("ground tr", y_test)
#print("predicted", preds)
#knn = KNeighborsClassifier(n_neighbors=10)
#clf = knn.fit(X_train, y_train)
#preds = knn.predict(X_test)
cm = confusion_matrix(y_test, preds)
scores = clf.score(X_test, y_test)
#print("Confusion matrix created")
#cmat = cmat + cm
total = float(cm.sum())
true = float(np.trace(cm))
scores_list.append(true/total)
#print(scores_list)
print(y_test)
if y_test[3] == 0: y_test[3] += 2
if y_test[4] == 0: y_test[4] += 2
if y_test[5] == 0: y_test[5] += 2
preds_cm = preds.copy()
if preds_cm[3] == 0: preds_cm[3] += 2
if preds_cm[4] == 0: preds_cm[4] += 2
if preds_cm[5] == 0: preds_cm[5] += 2
cm = confusion_matrix(y_test, preds_cm)
scores = clf.score(X_test, y_test)
print(y_test, preds_cm)
#print(cm)
print(np.array(preds), cm)
return np.array(preds), cm
def run_leave_one_block_out_crossvalidation_all(train_type, data_dict, svm_type):
# print("cross val on trial set", trial_set)
scores_list = []
X_data = []
y_data = []
for trial_set in range(NUM_TRIAL_SETS):
for block in range(len(data_dict['trial_set_' + str(trial_set + 1) + '_X'])):
# print(trial_set, block)
# X_train.append(data_dict['trial_set_'+str(trial_set+1)+'_X'][block, :])
if train_type == 'all_active' or train_type == 'all_active_passive':
X_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_X'][block, :])
y_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_y'][block])
elif train_type == 'noCW_active' or train_type == 'noCW_active_passive':
if block < 6:
X_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_X'][block, :])
y_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_y'][block])
print(np.shape(X_data))
print(np.shape(y_data))
X_data = np.array(X_data)
y_data = np.array(y_data)
cm_total = np.zeros((3, 3))
# skf = StratifiedKFold(y_data, n_folds=3, shuffle=True)
loo = LeaveOneOut(n=9)
#block_sets_test = [[0, 1, 2], [0, 1, 5], [0, 1, 8], [0, 2, 4], [0, 2, 7], [0, 4, 5], [0, 4, 8], [0, 5, 7],[0, 7, 8],
# [3, 1, 2], [3, 1, 5], [3, 1, 8], [3, 2, 4], [3, 2, 7], [3, 4, 5], [3, 4, 8], [3, 5, 7],[3, 7, 8],
# [6, 1, 2], [6, 1, 5], [6, 1, 8], [6, 2, 4], [6, 2, 7], [6, 4, 5], [6, 4, 8], [6, 5, 7],[6, 7, 8]]
block_sets_test = [[0, 3, 6], [0, 3, 7], [0, 3, 8], [0, 4, 6], [0, 4, 7], [0, 4, 8], [0, 5, 6], [0, 5, 7],[0, 5, 8],
[1, 3, 6], [1, 3, 7], [1, 3, 8], [1, 4, 6], [1, 4, 7], [1, 4, 8], [1, 5, 6], [1, 5, 7],[1, 5, 8],
[2, 3, 6], [2, 3, 7], [2, 3, 8], [2, 4, 6], [2, 4, 7], [2, 4, 8], [2, 5, 6], [2, 5, 7],[2, 5, 8]]
block_sets_train = []
for blocks_test in block_sets_test:
blocks_train = []
for i in range(9):
if i not in blocks_test:
blocks_train.append(i)
block_sets_train.append(blocks_train)
trial_set_skip = np.arange(0, 270, 9)
print(trial_set_skip)
for i in range(27):
train_block_index = block_sets_train[i]
test_block_index = block_sets_test[i]
#print(train_block_index, test_block_index)
train_index = []
for idx in train_block_index:
train_index.append(idx+trial_set_skip)
train_index = sorted(list(np.array(train_index).flatten()))
test_index = []
for idx in test_block_index:
test_index.append(idx+trial_set_skip)
test_index = sorted(list(np.array(test_index).flatten()))
print("TRAIN:", train_index, "TEST:", test_index)
X_train, X_test = X_data[train_index], X_data[test_index]
y_train, y_test = y_data[train_index], y_data[test_index]
print(X_test)
print(y_test)
svc = svm.SVC(kernel=svm_type)
# svc = svm.SVC(kernel='rbf')
# svc = svm.SVC(kernel='poly', degree=3)
clf = svc.fit(X_train, y_train)
preds = svc.predict(X_test)
# print(y_test, preds)
cm = confusion_matrix(y_test, preds, labels=[0, 1, 2])
scores = clf.score(X_test, y_test)
# print("Confusion matrix created")
# cmat = cmat + cm
total = float(cm.sum())
true = float(np.trace(cm))
scores_list.append(true / total)
# print(scores_list)
scores = clf.score(X_test, y_test)
#print(test_index, y_test, np.array(preds))
cm_total += cm
print(cm)
print(cm_total)
print(cm_total.T)
print(cm_total.T/9)
#cm_total.T
return scores, cm_total
def run_kfold_crossvalidation_all(train_type, data_dict, svm_type):
#print("cross val on trial set", trial_set)
scores_list = []
X_data = []
y_data = []
for trial_set in range(NUM_TRIAL_SETS):
for block in range(len(data_dict['trial_set_' + str(trial_set + 1) + '_X'])):
#print(trial_set, block)
#X_train.append(data_dict['trial_set_'+str(trial_set+1)+'_X'][block, :])
if train_type == 'all_active' or train_type == 'all_active_passive':
X_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_X'][block, :])
y_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_y'][block])
elif train_type == 'noCW_active' or train_type == 'noCW_active_passive':
if block < 6:
X_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_X'][block, :])
y_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_y'][block])
print(np.shape(X_data))
print(np.shape(y_data))
X_data = np.array(X_data)
y_data = np.array(y_data)
cm_total = | np.zeros((3,3)) | numpy.zeros |
import cea
import os
import pandas as pd
import numpy as np
import pickle
from scipy.stats import triang
from scipy.stats import norm
from scipy.stats import uniform
from pyDOE import lhs
from cea.demand import demand_main
from geopandas import GeoDataFrame as Gdf
import cea.inputlocator as inputlocator
from cea.demand.calibration.settings import subset_samples
from keras.layers import Input, Dense
from keras.models import Model
import scipy.io
from keras.models import Sequential
from keras.callbacks import EarlyStopping
from sklearn.preprocessing import MinMaxScaler
import cea.config
__author__ = "<NAME>"
__copyright__ = "Copyright 2017, Architecture and Building Systems - ETH Zurich"
__credits__ = ["<NAME>","<NAME>"]
__license__ = "MIT"
__version__ = "0.1"
__maintainer__ = "<NAME>"
__email__ = "<EMAIL>"
__status__ = "Testing"
all_results=[]
def simulate_demand_sample(locator, building_name, output_parameters):
"""
This script runs the cea demand tool in series and returns a single value of cvrmse and rmse.
:param locator: pointer to location of files in CEA
:param building_name: name of building
:param output_parameters: building load to consider in the anlysis
:return:
"""
# force simulation to be sequential and to only do one building
gv = cea.globalvar.GlobalVariables()
gv.multiprocessing = False
gv.print_totals = False
gv.simulate_building_list = [building_name]
gv.testing = True
#import weather and measured data
weather_path = locator.get_default_weather()
#weather_path = 'C:\CEAforArcGIS\cea\databases\weather\Zurich.epw'
#calculate demand timeseries for buidling an calculate cvrms
demand_main.demand_calculation(locator, weather_path, gv)
output_folder=locator.get_demand_results_folder()
file_path=os.path.join(output_folder, "%(building_name)s.xls" % locals())
#file_path=locator.get_demand_results_file(building_name)
new_calcs = pd.read_excel(file_path)
#cv_rmse, rmse = calc_cv_rmse(time_series_simulation[output_parameters].values, time_series_measured[output_parameters].values)
return new_calcs #cv_rmse, rmse
def latin_sampler(locator, num_samples, variables, region):
"""
This script creates a matrix of m x n samples using the latin hypercube sampler.
for this, it uses the database of probability distribtutions stored in locator.get_uncertainty_db()
:param locator: pointer to locator of files of CEA
:param num_samples: number of samples to do
:param variables: list of variables to sample
:return:
1. design: a matrix m x n with the samples
2. pdf_list: a dataframe with properties of the probability density functions used in the excercise.
"""
# get probability density function PDF of variables of interest
variable_groups = ('ENVELOPE', 'INDOOR_COMFORT', 'INTERNAL_LOADS')
database = pd.concat([pd.read_excel(locator.get_uncertainty_db(region), group, axis=1)
for group in variable_groups])
pdf_list = database[database['name'].isin(variables)].set_index('name')
# get number of variables
num_vars = pdf_list.shape[0] #alternatively use len(variables)
# get design of experiments
design = lhs(num_vars, samples=num_samples)
for i, variable in enumerate(variables):
distribution = pdf_list.loc[variable, 'distribution']
min = pdf_list.loc[variable,'min']
max = pdf_list.loc[variable,'max']
mu = pdf_list.loc[variable,'mu']
stdv = pdf_list.loc[variable,'stdv']
if distribution == 'triangular':
loc = min
scale = max - min
c = (mu - min) / (max - min)
design[:, i] = triang(loc=loc, c=c, scale=scale).ppf(design[:, i])
elif distribution == 'normal':
design[:, i] = norm(loc=mu, scale=stdv).ppf(design[:, i])
else: # assume it is uniform
design[:, i] = uniform(loc=min, scale=max).ppf(design[:, i])
return design, pdf_list
def prep_NN_inputs(NN_input,NN_target,NN_delays):
#NN_input.to_csv('TEMP.csv', index=False, header=False, float_format='%.3f', decimal='.')
#file_path_temp = 'C:\CEAforArcGIS\cea\surrogate\Temp.csv'
#input1 = pd.read_csv(file_path_temp)
input1=NN_input
target1=NN_target
nS, nF = input1.shape
nSS, nT = target1.shape
nD=NN_delays
aD=nD+1
input_matrix_features=np.zeros((nS+nD, aD*nF))
rowsF, colsF=input_matrix_features.shape
input_matrix_targets=np.zeros((nS+nD, aD*nT))
rowsFF, ColsFF = input_matrix_targets.shape
i=1
while i<aD+1:
j=i-1
aS=nS+j
m1=(i*nF)-(nF)
m2=(i*nF)
n1=(i*nT)-(nT)
n2=(i*nT)
input_matrix_features[j:aS, m1:m2]=input1
input_matrix_targets[j:aS, n1:n2]=target1
i=i+1
trimmed_inputn = input_matrix_features[nD:nS,:]
trimmed_inputt = input_matrix_targets[nD:nS, 2:]
NN_input_ready=np.concatenate([trimmed_inputn, trimmed_inputt], axis=1)
NN_target_ready=target1[nD:nS,:]
return NN_input_ready, NN_target_ready
def sampling_main(locator, variables, building_name, building_load, region):
"""
This script creates samples using a lating Hypercube sample of 5 variables of interest.
then runs the demand calculation of CEA for all the samples. It delivers a json file storing
the results of cv_rmse and rmse for each sample.
for more details on the work behind this please check:
<NAME>., <NAME>., <NAME>. Bayesian calibration of Dynamic building Energy Models. Applied Energy 2017.
:param locator: pointer to location of CEA files
:param variables: input variables of CEA to sample. They must be 5!
:param building_name: name of building to calibrate
:param building_load: name of building load to calibrate
:return:
1. a file storing values of cv_rmse and rmse for all samples. the file is sotred in
file(locator.get_calibration_cvrmse_file(building_name)
2 a file storing information about variables, the building_load and the probability distribtuions used in the
excercise. the file is stored in locator.get_calibration_problem(building_name)
:rtype: .json and .pkl
"""
# create list of samples with a LHC sampler and save to disk
samples, pdf_list = latin_sampler(locator, subset_samples, variables, region)
np.save(locator.get_calibration_samples(building_name), samples)
# create problem and save to disk as json
problem = {'variables':variables,
'building_load':building_load, 'probabiltiy_vars':pdf_list}
pickle.dump(problem, file(locator.get_calibration_problem(building_name), 'w'))
nn_X_ht = []
nn_X_cl = []
nn_T_ht = []
nn_T_cl = []
nn_X_ht = np.array(nn_X_ht)
nn_X_cl = np.array(nn_X_cl)
nn_T_ht = np.array(nn_T_ht)
nn_T_cl = | np.array(nn_T_cl) | numpy.array |
import unittest
import numpy as np
from phonopy.api_phonopy import Phonopy
from phonopy.spectrum.dynamic_structure_factor import atomic_form_factor_WK1995
from phonopy import load
import os
data_dir = os.path.dirname(os.path.abspath(__file__))
# <NAME> and <NAME>, Acta Cryst. A51, 416 (1995)
# f(Q) = \sum_i a_i \exp((-b_i Q^2) + c
# Q is in angstron^-1
# a1, b1, a2, b2, a3, b3, a4, b4, a5, b5, c
f_params = {'Na': [3.148690, 2.594987, 4.073989, 6.046925,
0.767888, 0.070139, 0.995612, 14.1226457,
0.968249, 0.217037, 0.045300], # 1+
'Cl': [1.061802, 0.144727, 7.139886, 1.171795,
6.524271, 19.467656, 2.355626, 60.320301,
35.829404, 0.000436, -34.916604], # 1-
'Si': [5.275329, 2.631338, 3.191038, 33.730728,
1.511514, 0.081119, 1.356849, 86.288640,
2.519114, 1.170087, 0.145073], # neutral
'Pb': [32.505656, 1.047035, 20.014240, 6.670321,
14.645661, 0.105279, 5.029499, 16.525040,
1.760138, 0.105279, 4.044678], # 4+
'Pb0': [16.419567, 0.105499, 32.738592, 1.055049,
6.530247, 25.025890, 2.342742, 80.906596,
19.916475, 6.664449, 4.049824],
'Te': [6.660302, 33.031656, 6.940756, 0.025750,
19.847015, 5.065547, 1.557175, 84.101613,
17.802427, 0.487660, -0.806668]} # neutral
data_AFF = """5.171588679 1.845620236 3.025894647 0.124171430 0.531444271 0.357372083
0.023856320 1.675511060 0.792733731 0.046252215 0.607606835 0.365938849
0.201611049 0.529561499 0.375299494 0.629569610 0.028195996 0.376744812
0.122785611 0.283082649 0.233015457 0.057604235 0.606819089 0.388606570
0.241073793 0.027598574 0.174838303 0.120170236 0.551166577 0.399921690
0.017676892 0.191317799 0.155253863 0.001382605 0.675194157 0.408290981
0.124073001 0.069254933 0.037429027 0.639561207 0.163254273 0.408934148
0.003757843 0.217553444 0.213773706 0.446843472 0.205635357 0.389828659
0.335273837 0.009258283 0.461748466 0.111918275 0.311894016 0.321054550
0.155257213 0.560104925 0.005767736 0.261429629 0.511077151 0.176362423"""
data_b = """99.367366854 35.461912077 57.989024624 1.109493894 4.748549446 3.191839110
0.483763005 33.976333211 15.902329182 0.422741848 5.553481879 3.338937967
4.324846943 11.359855711 7.850959264 5.886910551 0.263652029 3.509134839
2.773336666 6.393937243 5.030350431 0.550562310 5.799777024 3.688180663
5.647859305 0.646577389 3.821967934 1.171203888 5.371783065 3.853918874
0.418131844 4.525459914 3.344658336 0.013681138 6.681172229 3.970863352
2.850888142 1.591305647 0.373114126 6.375514924 3.354075619 3.970894110
0.079674882 4.612631104 2.112023136 4.414685828 3.888741010 3.698457365
6.120367922 0.169008406 4.303015992 1.042962054 5.252650957 2.818141845
2.305763345 8.318257049 0.039499076 1.790343459 7.590133448 1.207779368"""
def get_func_AFF(f_params):
def func(symbol, Q):
return atomic_form_factor_WK1995(Q, f_params[symbol])
return func
class TestDynamicStructureFactor(unittest.TestCase):
def setUp(self):
self.phonon = self._get_phonon()
mesh = [5, 5, 5]
self.phonon.set_mesh(mesh,
is_mesh_symmetry=False,
is_eigenvectors=True)
def tearDown(self):
pass
def show(self):
directions = np.array([[0.5, 0.5, 0.5],
[-0.5, 0.5, 0.5],
[0.5, -0.5, 0.5],
[0.5, 0.5, -0.5],
[0.5, -0.5, -0.5],
[-0.5, 0.5, -0.5],
[-0.5, -0.5, 0.5],
[-0.5, -0.5, -0.5]])
G_points_cubic = ([7, 1, 1], )
self._run(G_points_cubic, directions, verbose=True)
def test_IXS_G_to_L(self, verbose=False):
directions = np.array([[0.5, 0.5, 0.5], ])
n_points = 11
G_points_cubic = ([7, 1, 1], )
# Atomic form factor
self._run(G_points_cubic,
directions,
func_AFF=get_func_AFF(f_params),
n_points=n_points)
Q, S = self.phonon.get_dynamic_structure_factor()
data_cmp = np.reshape([float(x) for x in data_AFF.split()], (-1, 6))
for i in (([0, 1], [2], [3, 4], [5])):
np.testing.assert_allclose(
S[:6, i].sum(axis=1), data_cmp[:6, i].sum(axis=1), atol=1e-5)
if verbose:
print(S[:6, i].sum(axis=1) - data_cmp[:6, i].sum(axis=1))
for i in (([0, 1], [2, 3], [4], [5])):
np.testing.assert_allclose(
S[6:, i].sum(axis=1), data_cmp[6:, i].sum(axis=1), atol=1e-5)
if verbose:
print(S[6:, i].sum(axis=1) - data_cmp[6:, i].sum(axis=1))
# Scattering lengths
self._run(G_points_cubic,
directions,
scattering_lengths={'Na': 3.63, 'Cl': 9.5770},
n_points=n_points)
Q, S = self.phonon.get_dynamic_structure_factor()
data_cmp = np.reshape([float(x) for x in data_b.split()], (-1, 6))
for i in (([0, 1], [2], [3, 4], [5])):
np.testing.assert_allclose(
S[:6, i].sum(axis=1), data_cmp[:6, i].sum(axis=1), atol=1e-5)
if verbose:
print(S[:6, i].sum(axis=1) - data_cmp[:6, i].sum(axis=1))
for i in (([0, 1], [2, 3], [4], [5])):
np.testing.assert_allclose(
S[6:, i].sum(axis=1), data_cmp[6:, i].sum(axis=1), atol=1e-5)
if verbose:
print(S[6:, i].sum(axis=1) - data_cmp[6:, i].sum(axis=1))
def plot_f_Q(f_params):
import matplotlib.pyplot as plt
x = np.linspace(0.0, 6.0, 101)
for elem in ('Si', 'Na', 'Cl', 'Pb', 'Pb0', 'Te'):
y = [atomic_form_factor_WK1995(Q, f_params[elem]) for Q in x]
plt.plot(x, y, label=elem)
plt.xlim(xmin=0)
plt.ylim(ymin=0)
plt.legend()
plt.show()
def _run(self,
G_points_cubic,
directions,
func_AFF=None,
scattering_lengths=None,
n_points=51):
P = [[0, 0.5, 0.5],
[0.5, 0, 0.5],
[0.5, 0.5, 0]]
G_to_L = np.array(
[directions[0] * x
for x in np.arange(0, n_points) / float(n_points - 1)])
self.phonon.set_band_structure([G_to_L])
_, distances, frequencies, _ = self.phonon.get_band_structure()
T = 300
for G_cubic in G_points_cubic:
G_prim = np.dot(G_cubic, P)
for direction in directions:
direction_prim = np.dot(direction, P)
G_to_L = np.array(
[direction_prim * x
for x in np.arange(1, n_points) / float(n_points - 1)])
if func_AFF is not None:
self.phonon.set_dynamic_structure_factor(
G_to_L,
G_prim,
T,
func_atomic_form_factor=func_AFF,
freq_min=1e-3,
run_immediately=False)
elif scattering_lengths is not None:
self.phonon.set_dynamic_structure_factor(
G_to_L,
G_prim,
T,
scattering_lengths=scattering_lengths,
freq_min=1e-3,
run_immediately=False)
else:
raise SyntaxError
dsf = self.phonon.dynamic_structure_factor
for i, S in enumerate(dsf):
pass
def _get_phonon(self):
filename_cell = os.path.join(data_dir, "..", "POSCAR_NaCl")
filename_forces = os.path.join(data_dir, "..", "FORCE_SETS_NaCl")
filename_born = os.path.join(data_dir, "..", "BORN_NaCl")
phonon = load( | np.diag([2, 2, 2]) | numpy.diag |
from deepnn.core import *
import unittest
import numpy as np
import pprint
class TestCore(unittest.TestCase):
def test_initialization(self):
nn = NeuralNetwork([5, 4, 3], seed = 3)
self.assertEqual(nn.L, 2)
try:
np.testing.assert_allclose(nn.W[1],
[[ 0.01788628, 0.0043651, 0.00096497, -0.01863493, -0.00277388],
[-0.00354759, -0.00082741, -0.00627001, -0.00043818, -0.00477218],
[-0.01313865, 0.00884622, 0.00881318, 0.01709573, 0.00050034],
[-0.00404677, -0.0054536, -0.01546477, 0.00982367, -0.01101068]], rtol=1e-5)
except AssertionError:
self.fail("Failed initialize_parameters W1")
try:
np.testing.assert_array_equal(nn.b[1], [[0.], [0.], [0.], [0.]])
except AssertionError:
self.fail("Failed initialize_parameters b1")
try:
np.testing.assert_allclose(nn.W[2],
[[-0.01185047, -0.0020565, 0.01486148, 0.00236716],
[-0.01023785, -0.00712993, 0.00625245, -0.00160513],
[-0.00768836, -0.00230031, 0.00745056, 0.01976111]], rtol=1e-5)
except AssertionError:
self.fail("Failed initialize_parameters W2")
try:
np.testing.assert_array_equal(nn.b[2], [[0.], [0.], [0.]])
except AssertionError:
self.fail("Failed initialize_parameters b2")
def test_linear_forward(self):
np.random.seed(1)
A_prev = np.random.randn(3,2)
W = np.random.randn(1,3)
b = np.random.randn(1,1)
nn = NeuralNetwork([3, 1], seed = 1)
nn.W[1], nn.b[1] = W, b
self.assertEqual(nn.L, 1)
Z = nn._linear_forward(A_prev, 1)
try:
np.testing.assert_allclose(Z, [[ 3.26295337, -1.23429987]], rtol=1e-5)
except AssertionError:
self.fail("Failed linear_forward")
def test_linear_activation_forward(self):
np.random.seed(2)
A_prev = np.random.randn(3,2)
W = np.random.randn(1,3)
b = np.random.randn(1,1)
nn = NeuralNetwork([3, 1], seed = 1)
nn.W[1], nn.b[1] = W, b
A, linear_activation_cache = nn._linear_activation_forward(A_prev, 1, activation = "sigmoid")
try:
np.testing.assert_allclose(A, [[ 0.96890023, 0.11013289 ]], rtol=1e-5)
except AssertionError:
self.fail("Failed linear_activation_forward with sigmoid")
A, linear_activation_cache = nn._linear_activation_forward(A_prev, 1, activation = "relu")
try:
np.testing.assert_allclose(A, [[ 3.43896131, 0. ]], rtol=1e-5)
except AssertionError:
self.fail("Failed linear_activation_forward with ReLU")
def test_L_model_forward(self):
np.random.seed(6)
X = np.random.randn(5,4)
W1, b1 = np.random.randn(4,5), np.random.randn(4,1)
W2, b2 = np.random.randn(3,4), np.random.randn(3,1)
W3, b3 = np.random.randn(1,3), np.random.randn(1,1)
nn = NeuralNetwork([5, 4, 3, 1], seed = 6)
self.assertEqual(nn.L, 3)
nn.W[1], nn.b[1] = W1, b1
nn.W[2], nn.b[2] = W2, b2
nn.W[3], nn.b[3] = W3, b3
AL = nn.L_model_forward(X)
try:
np.testing.assert_allclose(AL, [[ 0.03921668, 0.70498921, 0.19734387, 0.04728177]], rtol=1e-5)
except AssertionError:
self.fail("Failed L_model_forward with AL")
self.assertEqual(len(nn.caches), 3)
def test_cross_entropy(self):
Y = | np.asarray([[1, 1, 1]]) | numpy.asarray |
import numpy as np
def trade_quote_processing(t, dates_quotes, q_ask, p_ask, q_bid, p_bid, t_n,
dates_trades, p_last, delta_q, delta_sgn,
match, varargin=None):
"""For details, see here.
Parameters
----------
t : array, shape (k1_,)
dates_quotes : array, shape (k1_,)
q_ask : array, shape (k1_,)
p_ask : array, shape (k1_,)
q_bid : array, shape (k1_,)
p_bid : array, shape (k1_,)
t_n : array, shape (k3_,)
dates_trades : array, shape (k3_,)
p_last : array, shape (k3_,)
delta_q : array, shape (k3_,)
delta_sgn : array, shape (k3_,)
match : array, shape (k3_,)
varargin{1} : array, shape (k1_,)
varargin{2} : array, shape (k1_,)
Returns
-------
t_p : array, shape (k1_,)
dates_quotes_p : array, shape (k1_,)
q_ask_p : array, shape (k1_,)
p_ask_p : array, shape (k1_,)
q_bid_p : array, shape (k1_,)
p_bid_p : array, shape (k1_,)
t_n_p : array, shape (k2_,)
dates_trades_p : array, shape (k2_,)
p_last_p : array, shape (k2_,)
delta_q_p : array, shape (k2_,)
delta_sgn_p : array, shape (k2_,)
varargout{1} : array, shape (k1_,)
varargout{2} : array, shape (k1_,)
"""
## QUOTES: if there are repeated times, consider the last stored observation and delete the others
t_unique = np.unique(t)
k1_ = len(t_unique)
dates_quotes_p = {}
t_p = np.zeros(k1_)
p_bid_p = np.zeros(k1_)
p_ask_p = np.zeros(k1_)
q_bid_p = np.zeros(k1_)
q_ask_p = np.zeros(k1_)
varargout = {1: np.zeros(k1_), 2: | np.zeros(k1_) | numpy.zeros |
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
import numpy as np
import sys
sys.path.append('/home/groups/ZuckermanLab/copperma/cell/celltraj')
import celltraj
import h5py
import pickle
import os
import subprocess
import time
sys.path.append('/home/groups/ZuckermanLab/copperma/msmWE/BayesianBootstrap')
import bootstrap
import umap
import pyemma.coordinates as coor
import scipy
modelList=['PBS_17nov20','EGF_17nov20','HGF_17nov20','OSM_17nov20','BMP2_17nov20','IFNG_17nov20','TGFB_17nov20']
nmodels=len(modelList)
modelSet=[None]*nmodels
for i in range(nmodels):
modelName=modelList[i]
objFile=modelName+'_coords.obj'
objFileHandler=open(objFile,'rb')
modelSet[i]=pickle.load(objFileHandler)
objFileHandler.close()
wctm=celltraj.cellTraj()
fileSpecifier='/home/groups/ZuckermanLab/copperma/cell/live_cell/mcf10a/batch_17nov20/*_17nov20.h5'
print('initializing...')
wctm.initialize(fileSpecifier,modelName)
nfeat=modelSet[0].Xf.shape[1]
Xf=np.zeros((0,nfeat))
indtreatment=np.array([])
indcellSet=np.array([])
for i in range(nmodels):
Xf=np.append(Xf,modelSet[i].Xf,axis=0)
indtreatment=np.append(indtreatment,i*np.ones(modelSet[i].Xf.shape[0]))
indcellSet=np.append(indcellSet,modelSet[i].cells_indSet)
indtreatment=indtreatment.astype(int)
indcellSet=indcellSet.astype(int)
Xpca,pca=wctm.get_pca_fromdata(Xf,var_cutoff=.9)
wctm.Xpca=Xpca
wctm.pca=pca
for i in range(nmodels):
indsf=np.where(indtreatment==i)[0]
modelSet[i].Xpca=Xpca[indsf,:]
all_trajSet=[None]*nmodels
for i in range(nmodels):
modelSet[i].get_unique_trajectories()
all_trajSet[i]=modelSet[i].trajectories.copy()
self=wctm
for trajl in [8]: #,2,3,4,5,6,7,8,9,10,12,14,16,18,20,25,30,26]:
wctm.trajl=trajl
Xpcat=np.zeros((0,pca.ndim*trajl))
indtreatment_traj=np.array([])
indstack_traj=np.array([])
indframes_traj=np.array([])
cellinds0_traj=np.array([])
cellinds1_traj=np.array([])
for i in range(nmodels):
modelSet[i].trajectories=all_trajSet[i].copy()
modelSet[i].trajl=trajl
modelSet[i].traj=modelSet[i].get_traj_segments(trajl)
data=modelSet[i].Xpca[modelSet[i].traj,:]
data=data.reshape(modelSet[i].traj.shape[0],modelSet[i].Xpca.shape[1]*trajl)
Xpcat=np.append(Xpcat,data,axis=0)
indtreatment_traj=np.append(indtreatment_traj,i*np.ones(data.shape[0]))
indstacks=modelSet[i].cells_imgfileSet[modelSet[i].traj[:,0]]
indstack_traj=np.append(indstack_traj,indstacks)
indframes=modelSet[i].cells_frameSet[modelSet[i].traj[:,0]]
indframes_traj=np.append(indframes_traj,indframes)
cellinds0=modelSet[i].traj[:,0]
cellinds0_traj=np.append(cellinds0_traj,cellinds0)
cellinds1=modelSet[i].traj[:,-1]
cellinds1_traj=np.append(cellinds1_traj,cellinds1)
cellinds0_traj=cellinds0_traj.astype(int)
cellinds1_traj=cellinds1_traj.astype(int)
for neigen in [2]: #[1,2,3,4,5]:
reducer=umap.UMAP(n_neighbors=200,min_dist=0.1, n_components=neigen, metric='euclidean')
trans = reducer.fit(Xpcat)
x=trans.embedding_
indst=np.arange(x.shape[0]).astype(int)
wctm.Xtraj=x.copy()
wctm.indst=indst.copy()
indconds=np.array([[0,1],[2,3],[4,5]]).astype(int)
ncond=3
fl=12
fu=96
nbinstotal=15.*15.
indstw=np.where(np.logical_and(indframes_traj[indst]<fu,indframes_traj[indst]>fl))[0]
probSet=[None]*nmodels
avoverlapSet=np.zeros(ncond)
prob1,edges=np.histogramdd(x[indstw,:],bins=int(np.ceil(nbinstotal**(1./neigen))),density=True)
for icond in range(ncond):
imf1=indconds[icond,0]
imf2=indconds[icond,1]
inds_imf1=np.where(indstack_traj==imf1)[0]
inds_imf2=np.where(indstack_traj==imf2)[0]
inds_cond=np.append(inds_imf1,inds_imf2)
for imf in range(nmodels):
indstm=np.where(indtreatment_traj==imf)[0]
indstm_cond=np.intersect1d(indstm,inds_cond)
xt=x[indstm_cond,0:neigen]
indg=np.where(np.logical_not(np.logical_or(np.isnan(xt[:,0]),np.isinf(xt[:,0]))))[0]
xt=xt[indg]
prob,edges2=np.histogramdd(xt,bins=edges,density=True) #for d=1
prob=prob/np.sum(prob)
probSet[imf]=prob.copy()
poverlapMatrix=np.zeros((nmodels,nmodels))
for i in range(nmodels):
for j in range(nmodels):
probmin=np.minimum(probSet[i],probSet[j])
poverlapMatrix[i,j]=np.sum(probmin)
avoverlapSet[icond]=np.mean(poverlapMatrix[np.triu_indices(nmodels,1)])
sys.stdout.write('avoverlap: '+str(avoverlapSet[0])+' '+str(avoverlapSet[1])+' '+str(avoverlapSet[2])+'\n')
#np.savetxt('avoverlapSet_UMAP_trajl'+str(trajl)+'_ndim'+str(neigen)+'_19feb21.dat',avoverlapSet)
for i in range(nmodels):
modelSet[i].trajectories=all_trajSet[i].copy()
indconds=np.array([[0,1],[2,3],[4,5]]).astype(int)
ncond=3
probSet=[None]*nmodels
sigdxSet=np.zeros(ncond)
sigxSet=np.zeros(ncond)
dxSet=np.zeros(ncond)
x0= | np.zeros((0,neigen)) | numpy.zeros |
import numpy as np
import chainer
from chainer import serializers
import onnx_chainer
from PIL import Image
from model import FastStyleNet, postprocess
def main():
chainer.config.train = False
model = FastStyleNet()
serializers.load_npz('./chainer-fast-neuralstyle-models/models/starrynight.model', model)
input = './test1.jpg'
original = Image.open(input).convert('RGB')
print(original.size)
image = | np.asarray(original, dtype=np.float32) | numpy.asarray |
import numpy as np
from sklearn.neighbors import BallTree, KDTree
import os
from baselines.deepq.experiments.atari.lru_knn_gpu_bp import LRU_KNN_GPU_BP
import gc
from baselines.deepq.experiments.atari.knn_cuda_fixmem import knn as knn_cuda_fixmem
import copy
class LRU_KNN_COMBINE_BP(object):
def __init__(self, num_actions, buffer_size, latent_dim, hash_dim, gamma=0.99, bp=True):
self.ec_buffer = []
self.num_actions = num_actions
self.gamma = gamma
self.rmax = 100000
self.bp = bp
for i in range(num_actions):
self.ec_buffer.append(LRU_KNN_GPU_BP(buffer_size, latent_dim, hash_dim, 'game'))
def add(self, action, key, value, reward, done, brothers):
buffer = self.ec_buffer[action]
if buffer.curr_capacity >= buffer.capacity:
# find the LRU entry
index = | np.argmin(buffer.lru) | numpy.argmin |
import hnswlib
import numpy as np
from disjoint_set import DisjointSet
from tqdm import tqdm_notebook as tqdm
import torch
from scipy.spatial import ConvexHull
from itertools import chain
import networkx as nx
from matplotlib import pyplot as plt
from matplotlib.ticker import MaxNLocator
def HNSWNearestNeighbors(X, k=2):
'''For a given set of points X finds k nearest neighbors for every point
Parameters
----------
X : array-like, shape (n_samples, n_features)
Point data to find nearest neighbors,
where n_samples is the number of samples
and n_features is the number of features.
Returns
-------
labels : array-like, shape (n_samples, k)
indices of k nearest neighbors for every point
distances : array-like, shape (n_samples, k)
distances to k nearest neighbors in increasing order
'''
X_float32 = np.array(X, dtype=np.float32)
X_labels = np.arange(len(X))
# Declaring index
p = hnswlib.Index(space='l2', dim=X.shape[1]) # possible options are l2, cosine or ip
# Initing index - the maximum number of elements should be known beforehand
p.init_index(max_elements=len(X), ef_construction=200, M=16)
# Element insertion (can be called several times):
p.add_items(X_float32, X_labels)
# Controlling the recall by setting ef:
p.set_ef(50 + k) # ef should always be > k
return p.knn_query(X, k=k)
def GetLowPoints(Cub, f, threshold, num, batch = 100, show_bar = True):
thetas = np.zeros((0, f.param_dim))
values = np.zeros(0)
if show_bar:
pbar = tqdm(total=num)
while len(thetas) < num:
thetas_batch = Cub.get_points(batch)
values_batch = f(thetas_batch)
mask = values_batch < threshold
thetas = np.vstack([thetas, thetas_batch[mask]])
values = np.concatenate([values, values_batch[mask]])
if show_bar:
pbar.update(np.sum(mask))
del thetas_batch
return thetas, values
class Cube:
def __init__(self, min_point, max_point):
self.min = min_point
self.max = max_point
self.dim = max_point.shape[0]
def check_points(self, points):
return np.logical_and(np.all(self.min < points, axis=1),
np.all(self.max > points, axis=1))
def get_points(self, num = 1):
return self.min + (self.max - self.min)*np.random.rand(num, self.dim)
class NetworkDataSetLoss:
def __init__(self, hidden_layer_sizes, X, Y, activation='tanh', max_batch_size=500000):
assert type(X) == torch.Tensor
assert type(Y) == torch.Tensor
assert X.device == Y.device
self.device = X.device
self.max_batch_size = max_batch_size
self.hidden_layer_sizes = hidden_layer_sizes
self.b_shapes = tuple(hidden_layer_sizes) + (Y.shape[1],)
self.W_shapes = tuple(zip(
[X.shape[1],] + list(hidden_layer_sizes),
self.b_shapes
))
self.param_dim = np.sum([np.prod(W_shape) for W_shape in self.W_shapes]) + np.sum(self.b_shapes)
if activation == 'relu':
self.activation = torch.relu
elif activation == 'tanh':
self.activation = torch.tanh
self.X = X.clone().detach()
self.Y = Y.clone().detach()
def to(self, device):
self.X = self.X.to(device)
self.Y = self.Y.to(device)
self.device = device
def predict(self, thetas, with_grads=True):
# assert thetas.shape[0] <= self.max_batch_size
output = self.X.unsqueeze(0)
pos = 0
for d in range(len(self.W_shapes)):
W_shape, b_shape = self.W_shapes[d], self.b_shapes[d]
W_len, b_len = np.prod(W_shape), np.prod(b_shape)
Ws = thetas[:, pos:pos+W_len].reshape(-1, *W_shape)
pos += W_len
bs = thetas[:, pos:pos+b_len].reshape(-1, b_shape)
pos += b_len
# output = torch.bmm(output, Ws) + bs[:,None,:]
output = torch.matmul(output, Ws)
output.add_(bs.unsqueeze(1))
if d != len(self.W_shapes) - 1:
output = self.activation(output)
del Ws, bs
output = output if with_grads else output.detach()
# torch.cuda.empty_cache()
return output
def __call__(self, thetas, with_grads=True):
if with_grads:
# assert len(thetas) <= self.max_batch_size
Y_pred = self.predict(thetas, with_grads=with_grads)
losses = ((Y_pred - self.Y) ** 2).flatten(start_dim=1).mean(dim=1)
return losses
with torch.no_grad():
result = []
for thetas_batch in tqdm(torch.split(thetas, self.max_batch_size)):
Y_pred = self.predict(thetas_batch, with_grads=with_grads)
losses = ((Y_pred - self.Y) ** 2).flatten(start_dim=1).mean(dim=1)
result.append(losses.detach())
torch.cuda.empty_cache()
torch.cuda.empty_cache()
return torch.cat(result).detach()
class ReLUFixedBiasFullyConnectedNetworkDataSetLoss:
def __init__(
self, hidden_layer_sizes, biases, X, Y,
max_batch_size=500000, lambda_l1=0., lambda_l2=0., last_bias_on=True
):
assert type(X) == torch.Tensor
assert type(Y) == torch.Tensor
assert X.device == Y.device
assert lambda_l1 >= 0
assert lambda_l2 >= 0
self.lambda_l1 = lambda_l1
self.lambda_l2 = lambda_l2
self.device = X.device
self.max_batch_size = max_batch_size
self.biases = [torch.tensor(bias, dtype=torch.float32, device=self.device) for bias in biases]
self.last_bias = last_bias_on
self.hidden_layer_sizes = hidden_layer_sizes
self.b_shapes = tuple(hidden_layer_sizes) + (Y.shape[1],)
self.W_shapes = tuple(zip(
[X.shape[1],] + list(hidden_layer_sizes),
self.b_shapes
))
self.param_dim = np.sum([np.prod(W_shape) for W_shape in self.W_shapes])
if last_bias_on:
self.param_dim += np.prod(self.b_shapes[-1])
self.X = X.clone().detach()
self.Y = Y.clone().detach()
def to(self, device):
self.X = self.X.to(device)
self.Y = self.Y.to(device)
self.biases = [bias.to(device) for bias in self.biases]
self.device = device
def predict(self, thetas, inner=False):
assert (type(thetas) == torch.Tensor) or (type(thetas) == np.ndarray)
assert len(thetas) <= self.max_batch_size
if type(thetas) == np.ndarray:
return self.predict(
torch.tensor(thetas, device=self.device, dtype=torch.float32)
).cpu().detach().numpy()
output = self.X.unsqueeze(0)
pos = 0
for d in range(len(self.W_shapes)):
W_shape, b_shape = self.W_shapes[d], self.b_shapes[d]
W_len, b_len = np.prod(W_shape), np.prod(b_shape)
Ws = thetas[:, pos:pos+W_len].reshape(-1, *W_shape)
pos += W_len
if d < len(self.W_shapes) - 1:
bs = self.biases[d].reshape(-1, b_shape)
else:
if self.last_bias:
bs = thetas[:, -b_len:].reshape(-1, b_shape)
else:
bs = torch.zeros((thetas.shape[0], b_shape), device=self.device, dtype=torch.float32)
output = torch.matmul(output, Ws)
output.add_(bs.unsqueeze(1))
if d != len(self.W_shapes) - 1:
output = torch.relu(output)
if d == len(self.W_shapes) - 1 and not inner:
ad = ((self.Y - output).flatten(start_dim=1).mean(dim=1))/(1 + self.lambda_l2)
output.add_(ad.reshape(output.shape[0], 1, 1))
return output
def _compute_regularization(self, thetas):
return self.lambda_l1 * torch.abs(thetas).sum(dim=1) + self.lambda_l2 * ((thetas) ** 2).sum(dim=1)
def __call__(self, thetas):
assert (type(thetas) == torch.Tensor) or (type(thetas) == np.ndarray)
if type(thetas) == torch.Tensor:
assert len(thetas) <= self.max_batch_size
# assert thetas.device == self.device
Y_pred = self.predict(thetas, inner=True)
if not self.last_bias:
addition = ((self.Y - Y_pred).flatten(start_dim=1).mean(dim=1))/(1 + self.lambda_l2)
Y_pred.add_(addition.reshape(Y_pred.shape[0], 1, 1))
losses = ((Y_pred - self.Y) ** 2).flatten(start_dim=1).mean(dim=1)
if not self.last_bias:
losses.add_(self.lambda_l2*addition**2)
return losses + self._compute_regularization(thetas)
with torch.no_grad():
result = []
start = 0
while start < len(thetas):
thetas_batch = torch.tensor(
thetas[start:start+self.max_batch_size],
device=self.device, dtype=torch.float32
)
result.append(self(thetas_batch).cpu().detach().numpy())
torch.cuda.empty_cache()
start += self.max_batch_size
torch.cuda.empty_cache()
return np.hstack(result)
def make_undirected(graph):
undirected_graph = graph.tolist()
for v1 in range(len(graph)):
for v2 in graph[v1]:
undirected_graph[v2].append(v1)
undirected_graph = [list(set(neighbors)) for neighbors in undirected_graph]
return undirected_graph
def make_rectangular(graph):
max_n = max([len(neighbors) for neighbors in graph])
for v in range(len(graph)):
graph[v] += [-1] * (max_n - len(graph[v]))
return graph
class ExtendedConvexHull(ConvexHull):
def __init__(self, points, volume_multiplier=1.):
super().__init__(points, incremental=False)
self.volume_multiplier = volume_multiplier
self._initialize_sampler()
def _initialize_sampler(self):
assert len(self.vertices) > self.ndim
pivot = self.simplices[0][0]
self._partition_idx = np.array(
[[pivot] + simplex.tolist() for simplex in self.simplices if pivot not in simplex],
dtype=int
)
partition_vol = np.array([
np.abs(np.linalg.det(self.points[idx][1:] - self.points[idx][0]))
for idx in self._partition_idx
])
self._partition_p = partition_vol / np.sum(partition_vol)
self.mass_center = np.zeros(self.ndim, dtype=float)
for idx, p in zip(self._partition_idx, self._partition_p):
self.mass_center += self.points[idx].mean(axis=0) * p
def add_points(self, *args, **kwargs):
raise Exception('Not supported. Please reinitialize from scratch.')
def sample(self, n_points):
simplex_idx = np.random.choice(range(len(self._partition_idx)), size=n_points, p=self._partition_p).astype(int)
points_idx = self._partition_idx[simplex_idx]
weights = np.random.dirichlet([1.] * (self.ndim+1), size=n_points)
points = self.points[points_idx.flatten().astype(int)].reshape(*points_idx.shape, -1,)
points = torch.tensor(points)
weights = torch.tensor(weights)
batch = torch.matmul(points.transpose(2, 1), weights[:, :, None]).numpy().sum(axis=2)
# Scaling
batch = self.mass_center + \
(batch - self.mass_center) * (self.volume_multiplier ** (1. / batch.shape[1]))
return batch
def get_dist_to_bounding_planes(self, points):
inner_dist = (points @ self.equations[:, :-1].T + self.equations[:, -1])
center_dist = (self.equations[:, :-1] @ self.mass_center + self.equations[:, -1])
return inner_dist + center_dist
def plot_barcodes(result, ax, min_cluster_size=20, title=''):
minima = result[result.dead_cluster_size >= min_cluster_size].copy()
minima = minima.sort_values('birth').reset_index()
# minima.set_index('id_dead_min', inplace=True)
for i, row in minima.iterrows():
ax.plot([i, i], [row.birth, row.death], c='darkslategrey')
ax.plot(
[0, 0],
[minima.iloc[0].birth, minima.death[minima.death < np.inf].max()],
c='darkslategrey', linestyle='--'
)
ax.scatter(
range(len(minima)),
minima.birth.values,
c='mediumblue', marker="v", edgecolor='black',
zorder=np.inf,
label='Value at Local Min'
)
ax.scatter(
range(len(minima)), minima.death.values,
c='red', edgecolor='black', marker='s', zorder=np.inf,
label='Value at 1-Saddle'
)
#ax.set_ylabel('Minima Barcode')
# ax.set_ylim(-0.03, 0.7)
ax.set_title(title)
plt.setp(ax.get_xticklabels(), visible=False)
ax.legend(fontsize=12)
return ax
def plot_graph(result, ax, min_cluster_size=20, title=''):
G = nx.DiGraph()
minima = result[result.dead_cluster_size >= min_cluster_size].copy()
minima = minima.sort_values('birth').reset_index()
for i, row in minima.iterrows():
G.add_edge(int(row.id_swallowed_min), int(row.id_dead_min), directed=True)
pos=nx.planar_layout(G)
nx.draw(G, pos, ax=ax, node_size=200, with_labels=False, font_size=10,)
def plot_2d_colormap(
f, ax,
scatter_points=None,
x_min=-1, y_min=-1, x_max=1, y_max=1,
grid_size=100, nbins=50,
title=None
):
X = np.linspace(x_min, x_max, grid_size)
Y = np.linspace(y_min, y_max, grid_size)
X, Y = | np.meshgrid(X, Y) | numpy.meshgrid |
import os
import re
import unittest
import numpy as np
import wfdb
class TestAnnotation(unittest.TestCase):
"""
Testing read and write of WFDB annotations, including Physionet
streaming.
Target files created using the original WFDB Software Package
version 10.5.24
"""
def test_1(self):
"""
Target file created with:
rdann -r sample-data/100 -a atr > ann-1
"""
annotation = wfdb.rdann("sample-data/100", "atr")
# This is not the fault of the script. The annotation file specifies a
# length 3
annotation.aux_note[0] = "(N"
# aux_note field with a null written after '(N' which the script correctly picks up. I am just
# getting rid of the null in this unit test to compare with the regexp output below which has
# no null to detect in the output text file of rdann.
# Target data from WFDB software package
lines = tuple(open("tests/target-output/ann-1", "r"))
nannot = len(lines)
target_time = [None] * nannot
target_sample = np.empty(nannot, dtype="object")
target_symbol = [None] * nannot
target_subtype = np.empty(nannot, dtype="object")
target_chan = np.empty(nannot, dtype="object")
target_num = np.empty(nannot, dtype="object")
target_aux_note = [None] * nannot
RXannot = re.compile(
"[ \t]*(?P<time>[\[\]\w\.:]+) +(?P<sample>\d+) +(?P<symbol>.) +(?P<subtype>\d+) +(?P<chan>\d+) +(?P<num>\d+)\t?(?P<aux_note>.*)"
)
for i in range(0, nannot):
(
target_time[i],
target_sample[i],
target_symbol[i],
target_subtype[i],
target_chan[i],
target_num[i],
target_aux_note[i],
) = RXannot.findall(lines[i])[0]
# Convert objects into integers
target_sample = target_sample.astype("int")
target_num = target_num.astype("int")
target_subtype = target_subtype.astype("int")
target_chan = target_chan.astype("int")
# Compare
comp = [
np.array_equal(annotation.sample, target_sample),
np.array_equal(annotation.symbol, target_symbol),
np.array_equal(annotation.subtype, target_subtype),
np.array_equal(annotation.chan, target_chan),
np.array_equal(annotation.num, target_num),
annotation.aux_note == target_aux_note,
]
# Test file streaming
pn_annotation = wfdb.rdann(
"100",
"atr",
pn_dir="mitdb",
return_label_elements=["label_store", "symbol"],
)
pn_annotation.aux_note[0] = "(N"
pn_annotation.create_label_map()
# Test file writing
annotation.wrann(write_fs=True)
write_annotation = wfdb.rdann(
"100", "atr", return_label_elements=["label_store", "symbol"]
)
write_annotation.create_label_map()
assert comp == [True] * 6
assert annotation.__eq__(pn_annotation)
assert annotation.__eq__(write_annotation)
def test_2(self):
"""
Annotation file with many aux_note strings.
Target file created with:
rdann -r sample-data/100 -a atr > ann-2
"""
annotation = wfdb.rdann("sample-data/12726", "anI")
# Target data from WFDB software package
lines = tuple(open("tests/target-output/ann-2", "r"))
nannot = len(lines)
target_time = [None] * nannot
target_sample = np.empty(nannot, dtype="object")
target_symbol = [None] * nannot
target_subtype = np.empty(nannot, dtype="object")
target_chan = np.empty(nannot, dtype="object")
target_num = np.empty(nannot, dtype="object")
target_aux_note = [None] * nannot
RXannot = re.compile(
"[ \t]*(?P<time>[\[\]\w\.:]+) +(?P<sample>\d+) +(?P<symbol>.) +(?P<subtype>\d+) +(?P<chan>\d+) +(?P<num>\d+)\t?(?P<aux_note>.*)"
)
for i in range(0, nannot):
(
target_time[i],
target_sample[i],
target_symbol[i],
target_subtype[i],
target_chan[i],
target_num[i],
target_aux_note[i],
) = RXannot.findall(lines[i])[0]
# Convert objects into integers
target_sample = target_sample.astype("int")
target_num = target_num.astype("int")
target_subtype = target_subtype.astype("int")
target_chan = target_chan.astype("int")
# Compare
comp = [
| np.array_equal(annotation.sample, target_sample) | numpy.array_equal |
from enum import Enum
import numpy as np
from qiskit.extensions import XGate, YGate, SGate, ZGate, HGate, TGate, RXGate, RYGate, RZGate, IdGate
from qiskit.circuit import Gate
from qiskit.circuit import QuantumRegister
def gen_predefined_payoffs(game_name: str, num_players: int, payoff_input: dict):
"""Generates payoff table based on game name"""
num_players = num_players
payoff_table = {}
if game_name == "minority":
for i in range(2**num_players):
outcome = format(i, '0'+str(num_players)+'b')
payoff = np.zeros(num_players)
if outcome.count('0') != 1 and outcome.count('1') != 1:
payoff_table[outcome] = tuple(payoff)
else:
if outcome.count('0') == 1:
win_ind = outcome.find('0')
payoff[win_ind] = 1
payoff_table[outcome] = tuple(payoff)
if outcome.count('1') == 1:
win_ind = outcome.find('1')
payoff[win_ind] = 1
payoff_table[outcome] = tuple(payoff)
elif game_name == "chicken":
for i in range(2**num_players):
outcome = format(i, '0'+str(num_players)+'b')
if outcome.count('1') == 0:
payoff_table[outcome] = tuple(np.zeros(num_players))
elif outcome.count('1') == 1:
payoff = np.array([])
for j in range(num_players):
if outcome[j] == '0':
payoff = np.append(payoff, -1)
else:
payoff = np.append(payoff, 1)
payoff_table[outcome] = tuple(payoff)
else:
payoff = np.array([])
for j in range(num_players):
if outcome[j] == '0':
payoff = np.append(payoff, 0)
else:
payoff = | np.append(payoff, -10) | numpy.append |
"""Analysis and modification of structural data exported from GeoModeller
All structural data from an entire GeoModeller project can be exported into ASCII
files using the function in the GUI:
Export -> 3D Structural Data
This method generates files for defined geological parameters:
"Points" (i.e. formation contact points) and
"Foliations" (i.e. orientations/ potential field gradients).
Exported parameters include all those defined in sections as well as 3D data points.
This package contains methods to check, visualise, and extract/modify parts of these
exported data sets, for example to import them into a different Geomodeller project.
"""
# import os, sys
import numpy as np
import numpy.random
import matplotlib.pyplot as plt
# from mpl_toolkits.mplot3d import Axes3D
class Struct3DPoints():
"""Class container for 3D structural points data sets"""
def __init__(self, **kwds):
"""Structural points data set
**Optional keywords**:
- *filename* = string : filename of csv file with exported points to load
"""
# store point information in purpose defined numpy record
self.ptype = np.dtype([('x', np.float32),
('y', np.float32),
('z', np.float32),
('formation', np.str_, 32)])
if kwds.has_key("filename"):
self.filename = kwds['filename']
# read data
self.parse()
self.get_formation_names()
self.get_range()
def parse(self):
"""Parse filename and load data into numpy record
The point information is stored in a purpose defined numpy record
self.points
"""
f = open(self.filename, "r")
lines = f.readlines()
self.header = lines[0]
# determine position of elements in header (for extension to foliations, etc.)
h_elem = np.array(self.header.rstrip().split(','))
x_id = np.where(h_elem == 'X')[0]
y_id = np.where(h_elem == 'Y')[0]
z_id = np.where(h_elem == 'Z')[0]
form_id = np.where(h_elem == 'formation')[0]
# print x_id
# create numpy array for points
self.len = (len(lines)-1)
self.points = np.ndarray(self.len, dtype = self.ptype)
for i,line in enumerate(lines[1:]):
l = line.rstrip().split(',')
self.points[i]['x'] = float(l[x_id])
self.points[i]['y'] = float(l[y_id])
self.points[i]['z'] = float(l[z_id])
self.points[i]['formation'] = l[form_id]
def get_formation_names(self):
"""Get names of all formations that have a point in this data set
and store in:
self.formation_names
"""
# self.formation_names = np.unique(self.formations)
self.formation_names = | np.unique(self.points[:]['formation']) | numpy.unique |
from __future__ import absolute_import, print_function, division
import theano
import theano.tensor as T
from theano import function, shared
from theano.tests import unittest_tools as utt
from theano.tensor.nnet.ConvTransp3D import convTransp3D, ConvTransp3D
from theano.tensor.nnet.ConvGrad3D import convGrad3D, ConvGrad3D
from theano.tensor.nnet.Conv3D import conv3D, Conv3D
from theano.tests.unittest_tools import attr
from nose.plugins.skip import SkipTest
import numpy as N
from six.moves import xrange
import copy
import theano.sparse
if theano.sparse.enable_sparse:
from scipy import sparse
floatX = theano.config.floatX
# TODO: each individual test method should seed rng with utt.fetch_seed()
# as it is right now, setUp does the seeding, so if you run just
# a subset of the tests they will do different things than if you
# run all of them
class DummyConv3D:
"""A dummy version of Conv3D passed to verify_grad
Stores a fixed stride, since stride is not differentiable
Exposes only one scalar argument, which is used as the position
along a parametrically defined line, with 0 being at VwbVals
Direction of the line is chosen randomly at construction
The reason for locking the inputs to lie on this line is so that the
verify_grad will not need to test hundreds of variables. Disadvantage
is we can't be certain that all of them are correct, advantange is that
this random projection lets us test lots of variables very quickly """
def __init__(self, rng, VWbVals, d):
"""
param: rng Random number generator used to pick direction of the
line
param: VWbVals tuple containing values to test V,W,b around
param: d shared variable for d, the stride
"""
self.V, self.W, self.b = VWbVals
self.dV = shared(rng.uniform(-1, 1,
self.V.get_value(borrow=True).shape))
self.dW = shared(rng.uniform(-1, 1,
self.W.get_value(borrow=True).shape))
self.db = shared(rng.uniform(-1, 1,
self.b.get_value(borrow=True).shape))
self.d = d
def __call__(self, t):
output = conv3D(self.V + t * self.dV, self.W + t * self.dW,
self.b + t * self.db, self.d)
return output
class DummyConvGrad3D:
def __init__(self, rng, VdHvals, d, WShape):
"""
param: rng Random number generator used to pick direction of the
line
param: VWbVals tuple containing values to test V,W,b around
param: d shared variable for d, the stride
"""
self.V, self.dCdH = VdHvals
self.dV = shared(rng.uniform(-1, 1,
self.V.get_value(borrow=True).shape))
self.ddCdH = shared(rng.uniform(
-1, 1, self.dCdH.get_value(borrow=True).shape))
self.d = d
self.WShape = WShape
def __call__(self, t):
output = convGrad3D(self.V + t * self.dV, self.d, self.WShape,
self.dCdH + t * self.ddCdH)
return output
class DummyConvTransp3D:
def __init__(self, rng, WbHvals, d, RShape):
"""
param: rng Random number generator used to pick direction of the
line
param: VWbVals tuple containing values to test V,W,b around
param: d shared variable for d, the stride
"""
self.W, self.b, self.H = WbHvals
self.dW = rng.uniform(-1, 1, self.W.get_value(borrow=True).shape)
self.db = rng.uniform(-1, 1, self.b.get_value(borrow=True).shape)
self.dH = rng.uniform(-1, 1, self.H.get_value(borrow=True).shape)
self.dW, self.db = shared(self.dW), shared(self.db),
self.dH = shared(self.dH)
self.d = d
self.RShape = RShape
def __call__(self, t):
output = convTransp3D(self.W + t * self.dW, self.b + t * self.db,
self.d, self.H + t * self.dH, self.RShape)
return output
class TestConv3D(utt.InferShapeTester):
def setUp(self):
super(TestConv3D, self).setUp()
utt.seed_rng()
self.rng = N.random.RandomState(utt.fetch_seed())
mode = copy.copy(theano.compile.mode.get_default_mode())
mode.check_py_code = False
self.W = shared(N.ndarray(shape=(1, 1, 1, 1, 1), dtype=floatX))
self.W.name = 'W'
self.b = shared(N.zeros(1, dtype=floatX))
self.b.name = 'b'
self.rb = shared(N.zeros(1, dtype=floatX))
self.rb.name = 'rb'
self.V = shared(N.ndarray(shape=(1, 1, 1, 1, 1), dtype=floatX))
self.V.name = 'V'
self.d = shared(N.ndarray(shape=(3, ), dtype=int))
self.d.name = 'd'
self.H = conv3D(self.V, self.W, self.b, self.d)
self.H.name = 'H'
self.H_func = function([], self.H, mode=mode)
self.H_shape_func = function([], self.H.shape, mode=mode)
self.RShape = T.vector(dtype='int64')
self.RShape.name = 'RShape'
self.otherH = T.TensorType(
floatX, (False, False, False, False, False))(name='otherH')
self.transp = convTransp3D(self.W, self.rb, self.d,
self.otherH, self.RShape)
self.transp.name = 'transp'
self.transp_func = function([self.otherH, self.RShape],
self.transp, mode=mode)
self.R = convTransp3D(self.W, self.rb, self.d, self.H, self.RShape)
self.R.name = 'R'
self.R_func = function([self.RShape], self.R, mode=mode)
self.R_shape_func = function([self.RShape], self.R.shape)
diff = self.V - self.R
diff.name = 'diff'
sqr = T.sqr(diff)
sqr.name = 'sqr'
self.reconsObj = T.sum(sqr)
self.reconsObj.name = 'reconsObj'
self.reconsObjFunc = function([self.RShape], self.reconsObj, mode=mode)
W_grad = T.grad(self.reconsObj, self.W)
self.gradientsFunc = function(
[self.RShape],
[W_grad, T.grad(self.reconsObj, self.H), T.grad(self.reconsObj, self.V),
T.grad(self.reconsObj, self.b)], mode=mode)
self.check_c_against_python = function(
[self.RShape],
[T.grad(self.reconsObj, self.W), T.grad(self.reconsObj, self.H), T.grad(self.reconsObj, self.V),
T.grad(self.reconsObj, self.b)], mode='DEBUG_MODE')
self.dCdW_shape_func = function([self.RShape], T.grad(self.reconsObj, self.W).shape, mode=mode)
def random_tensor(self, *dims):
return N.asarray(self.rng.uniform(-.05, .05, dims), dtype=floatX)
def randomize(self):
batchSize = self.rng.randint(1, 4)
videoDur = self.rng.randint(8, 30)
filterWidth = self.rng.randint(1, 8)
filterHeight = self.rng.randint(1, 8)
filterDur = self.rng.randint(1, 8)
tsteps = self.rng.randint(1, 4)
rsteps = self.rng.randint(1, 4)
csteps = self.rng.randint(1, 4)
videoDur = tsteps * filterDur + self.rng.randint(0, 3)
videoWidth = csteps * filterWidth + self.rng.randint(0, 3)
videoHeight = rsteps * filterHeight + self.rng.randint(0, 3)
numFilters = self.rng.randint(1, 3)
inputChannels = self.rng.randint(1, 3)
self.d.get_value(borrow=True, return_internal_type=True)[0] = \
self.rng.randint(1, 15)
self.d.get_value(borrow=True, return_internal_type=True)[1] = \
self.rng.randint(1, 15)
self.d.get_value(borrow=True, return_internal_type=True)[2] = \
self.rng.randint(1, 15)
int((videoHeight - filterHeight) /
self.d.get_value(borrow=True)[0]) + 1
int((videoWidth - filterWidth) /
self.d.get_value(borrow=True)[1]) + 1
int((videoDur - filterDur) /
self.d.get_value(borrow=True)[2]) + 1
self.W.set_value(self.random_tensor(
numFilters, filterHeight,
filterWidth, filterDur, inputChannels), borrow=True)
self.b.set_value(self.random_tensor(numFilters), borrow=True)
self.rb.set_value(self.random_tensor(inputChannels), borrow=True)
self.V.set_value(self.random_tensor(
batchSize, videoHeight,
videoWidth, videoDur, inputChannels), borrow=True)
self.rb.set_value(self.random_tensor(inputChannels), borrow=True)
def test_c_against_python(self):
self.randomize()
self.check_c_against_python(self.V.get_value(borrow=True).shape[1:4])
@attr('slow')
def test_c_against_mat_mul(self):
# Use a filter of the same size as the image, so the convolution is
# just a dense matrix multiply.
# Check that dense matrix multiplication gives the same result as
# convolution.
batchSize = self.rng.randint(1, 10)
videoDur = self.rng.randint(3, 10)
videoWidth = self.rng.randint(1, 5)
videoHeight = self.rng.randint(1, 5)
filterWidth = videoWidth
filterHeight = videoHeight
filterDur = videoDur
numFilters = self.rng.randint(1, 3)
inputChannels = self.rng.randint(1, 4)
self.d.get_value(borrow=True, return_internal_type=True)[0] = \
self.rng.randint(1, 15)
self.d.get_value(borrow=True, return_internal_type=True)[1] = \
self.rng.randint(1, 15)
self.d.get_value(borrow=True, return_internal_type=True)[2] = \
self.rng.randint(1, 15)
self.W.set_value(self.random_tensor(
numFilters, filterHeight,
filterWidth, filterDur, inputChannels), borrow=True)
self.W.set_value(
self.W.get_value(borrow=True) *
(self.W.get_value(borrow=True) < 1e-5), borrow=True)
self.b.set_value(self.random_tensor(numFilters), borrow=True)
self.V.set_value(self.random_tensor(
batchSize, videoHeight, videoWidth, videoDur, inputChannels), borrow=True)
Hv = self.H_func()
assert Hv.shape[1] == 1
assert Hv.shape[2] == 1
assert Hv.shape[3] == 1
n = inputChannels * videoHeight * videoWidth * videoDur
W_mat = N.zeros((n, numFilters))
V_mat = N.zeros((batchSize, n))
Hv_mat = N.zeros((batchSize, numFilters))
for qi in xrange(0, numFilters):
W_mat[:, qi] = \
self.W.get_value(borrow=True)[qi, :, :, :, :].reshape((n))
Hv_mat[:, qi] = Hv[:, 0, 0, 0, qi]
for qi in xrange(0, batchSize):
V_mat[qi, :] = \
self.V.get_value(borrow=True)[qi, :, :, :, :].reshape((n))
H_mat = N.dot(V_mat, W_mat) + self.b.get_value(borrow=True)
tol = 1e-5
if floatX == 'float32':
tol = 1e-4
if N.abs(H_mat - Hv_mat).max() > tol and not N.allclose(H_mat, Hv_mat):
print(H_mat)
print(Hv_mat)
print('max error: ' + str(N.abs(H_mat - Hv_mat).max()))
self.W.get_value(borrow=True)[self.W.get_value(borrow=True) != 0] += 1.0
print('min non-zero kernel mag: ' + str(
N.abs(self.W.get_value(borrow=True)).min()))
assert False
def test_c_against_mat_transp_mul(self):
# Use a filter of the same size as the image, so the convolution is just a
# dense matrix multiply.
# Check that dense matrix multiplication by the transpose of the matrix
# gives the same result as ConvTransp.
batchSize = self.rng.randint(1, 10)
videoDur = self.rng.randint(3, 15)
videoWidth = self.rng.randint(3, 15)
videoHeight = self.rng.randint(3, 15)
filterWidth = videoWidth
filterHeight = videoHeight
filterDur = videoDur
numFilters = self.rng.randint(1, 15)
inputChannels = self.rng.randint(1, 15)
self.d.get_value(borrow=True, return_internal_type=True)[0] = \
self.rng.randint(1, 15)
self.d.get_value(borrow=True, return_internal_type=True)[1] = \
self.rng.randint(1, 15)
self.d.get_value(borrow=True, return_internal_type=True)[2] = \
self.rng.randint(1, 15)
self.W.set_value(self.random_tensor(
numFilters, filterHeight,
filterWidth, filterDur, inputChannels), borrow=True)
self.b.set_value(self.random_tensor(numFilters), borrow=True)
self.V.set_value(self.random_tensor(
batchSize, videoHeight,
videoWidth, videoDur, inputChannels), borrow=True)
self.rb.set_value(self.random_tensor(inputChannels), borrow=True)
H_shape = self.H_shape_func()
assert H_shape[1] == 1
assert H_shape[2] == 1
assert H_shape[3] == 1
Hv = self.random_tensor(* H_shape)
Vv = self.transp_func(Hv, [videoHeight, videoWidth, videoDur])
n = inputChannels * videoHeight * videoWidth * videoDur
rbim = N.zeros((videoHeight, videoWidth, videoDur, inputChannels))
for qi in xrange(0, inputChannels):
rbim[:, :, :, qi] = self.rb.get_value(borrow=True)[qi]
rbv = rbim.reshape((n))
W_mat = N.zeros((numFilters, n))
Vv_mat = N.zeros((n, batchSize))
Hv_mat = N.zeros((numFilters, batchSize))
for qi in xrange(0, numFilters):
W_mat[qi, :] = \
self.W.get_value(borrow=True)[qi, :, :, :, :].reshape((n))
Hv_mat[qi, :] = Hv[:, 0, 0, 0, qi]
for qi in xrange(0, batchSize):
Vv_mat[:, qi] = Vv[qi, :, :, :, :].reshape((n))
V_mat = (N.dot(W_mat.transpose(), Hv_mat).transpose() +
rbv).transpose()
if N.abs(V_mat - Vv_mat).max() > 1e-5:
print(V_mat)
print(Vv_mat)
for qq in xrange(V_mat.shape[0]):
for qqq in xrange(Vv_mat.shape[1]):
if abs(V_mat[qq, qqq] - Vv_mat[qq, qqq]) > 1e-5:
print(
('wrong at ' + str((qq, qqq)) + ': ' +
str(V_mat[qq, qqq], Vv_mat[qq, qqq])))
assert False
def test_c_against_sparse_mat_transp_mul(self):
# like test_c_against_mat_transp_mul but using a sparse matrix and a kernel
# that is smaller than the image
if not theano.sparse.enable_sparse:
raise SkipTest('Optional package sparse disabled')
batchSize = self.rng.randint(1, 3)
filterWidth = self.rng.randint(1, 8)
filterHeight = self.rng.randint(1, 8)
filterDur = self.rng.randint(1, 8)
self.d.get_value(borrow=True, return_internal_type=True)[0] = \
self.rng.randint(1, 15)
self.d.get_value(borrow=True, return_internal_type=True)[1] = \
self.rng.randint(1, 15)
self.d.get_value(borrow=True, return_internal_type=True)[2] = \
self.rng.randint(1, 15)
dr = self.d.get_value(borrow=True)[0]
dc = self.d.get_value(borrow=True)[1]
dt = self.d.get_value(borrow=True)[2]
numFilters = self.rng.randint(1, 3)
row_steps = self.rng.randint(1, 4)
col_steps = self.rng.randint(1, 4)
time_steps = self.rng.randint(1, 4)
# print (row_steps,col_steps,time_steps)
videoDur = (time_steps - 1) * dt + filterDur + self.rng.randint(0, 3)
videoWidth = (col_steps - 1) * dc + filterWidth + self.rng.randint(0, 3)
videoHeight = (row_steps - 1) * dr + filterHeight + self.rng.randint(0, 3)
inputChannels = self.rng.randint(1, 15)
self.W.set_value(self.random_tensor(
numFilters, filterHeight,
filterWidth, filterDur, inputChannels), borrow=True)
self.b.set_value(self.random_tensor(numFilters), borrow=True)
# just needed so H_shape works
self.V.set_value(self.random_tensor(
batchSize, videoHeight, videoWidth,
videoDur, inputChannels), borrow=True)
self.rb.set_value(self.random_tensor(inputChannels), borrow=True)
H_shape = self.H_shape_func()
# make index maps
h = N.zeros(H_shape[1:], dtype='int32')
r = N.zeros(H_shape[1:], dtype='int32')
c = N.zeros(H_shape[1:], dtype='int32')
t = N.zeros(H_shape[1:], dtype='int32')
for qi in xrange(0, H_shape[4]):
h[:, :, :, qi] = qi
for qi in xrange(0, H_shape[1]):
r[qi, :, :, :] = qi
for qi in xrange(0, H_shape[2]):
c[:, qi, :, :] = qi
for qi in xrange(0, H_shape[3]):
t[:, :, qi, :] = qi
hn = H_shape[1] * H_shape[2] * H_shape[3] * H_shape[4]
h = h.reshape((hn))
r = r.reshape((hn))
c = c.reshape((hn))
t = t.reshape((hn))
Hv = self.random_tensor(*H_shape)
Vv = self.transp_func(Hv, [videoHeight, videoWidth, videoDur])
n = inputChannels * videoHeight * videoWidth * videoDur
rbim = N.zeros((videoHeight, videoWidth, videoDur, inputChannels))
for qi in xrange(0, inputChannels):
rbim[:, :, :, qi] = self.rb.get_value(borrow=True)[qi]
rbv = rbim.reshape((n))
W_mat = N.zeros((hn, n))
Vv_mat = | N.zeros((n, batchSize)) | numpy.zeros |
import pytest
import numpy as np
from devito import (Constant, Grid, TimeFunction, SparseTimeFunction, Operator,
Eq, ConditionalDimension, SubDimension, SubDomain, configuration)
from devito.ir import FindSymbols, retrieve_iteration_tree
from devito.exceptions import InvalidOperator
def test_read_write():
nt = 10
grid = Grid(shape=(4, 4))
u = TimeFunction(name='u', grid=grid, save=nt)
u1 = TimeFunction(name='u', grid=grid, save=nt)
eqn = Eq(u.forward, u + 1)
op0 = Operator(eqn, opt='noop')
op1 = Operator(eqn, opt='buffering')
# Check generated code
assert len(retrieve_iteration_tree(op1)) == 2
buffers = [i for i in FindSymbols().visit(op1) if i.is_Array]
assert len(buffers) == 1
assert buffers.pop().symbolic_shape[0] == 2
op0.apply(time_M=nt-2)
op1.apply(time_M=nt-2, u=u1)
assert np.all(u.data == u1.data)
def test_write_only():
nt = 10
grid = Grid(shape=(4, 4))
time = grid.time_dim
u = TimeFunction(name='u', grid=grid, save=nt)
u1 = TimeFunction(name='u', grid=grid, save=nt)
v = TimeFunction(name='v', grid=grid)
v1 = TimeFunction(name='v', grid=grid)
eqns = [Eq(v.forward, v + 1, implicit_dims=time),
Eq(u, v)]
op0 = Operator(eqns, opt='noop')
op1 = Operator(eqns, opt='buffering')
# Check generated code
assert len(retrieve_iteration_tree(op1)) == 1
buffers = [i for i in FindSymbols().visit(op1) if i.is_Array]
assert len(buffers) == 1
op0.apply(time_M=nt-2)
op1.apply(time_M=nt-2, u=u1, v=v1)
assert np.all(u.data == u1.data)
assert np.all(v.data == v1.data)
def test_read_only():
nt = 10
grid = Grid(shape=(2, 2))
u = TimeFunction(name='u', grid=grid, save=nt)
v = TimeFunction(name='v', grid=grid)
v1 = TimeFunction(name='v', grid=grid)
for i in range(nt):
u.data[i, :] = i
eqns = [Eq(v.forward, v + u.backward + u + u.forward + 1.)]
op0 = Operator(eqns, opt='noop')
op1 = Operator(eqns, opt='buffering')
# Check generated code
assert len(retrieve_iteration_tree(op1)) == 2
buffers = [i for i in FindSymbols().visit(op1) if i.is_Array]
assert len(buffers) == 1
op0.apply(time_M=nt-2)
op1.apply(time_M=nt-2, v=v1)
assert np.all(v.data == v1.data)
def test_read_only_w_offset():
nt = 10
grid = Grid(shape=(2, 2))
u = TimeFunction(name='u', grid=grid, save=nt)
v = TimeFunction(name='v', grid=grid)
v1 = TimeFunction(name='v', grid=grid)
for i in range(nt):
u.data[i, :] = i
eqns = [Eq(v.forward, v + u.backward + u + u.forward + 1.)]
op0 = Operator(eqns, opt='noop')
op1 = Operator(eqns, opt='buffering')
op0.apply(time_M=nt-2, time_m=4)
op1.apply(time_M=nt-2, time_m=4, v=v1)
assert np.all(v.data == v1.data)
def test_read_only_backwards():
nt = 10
grid = Grid(shape=(2, 2))
u = TimeFunction(name='u', grid=grid, save=nt)
v = TimeFunction(name='v', grid=grid)
v1 = TimeFunction(name='v', grid=grid)
for i in range(nt):
u.data[i, :] = i
eqns = [Eq(v.backward, v + u.backward + u + u.forward + 1.)]
op0 = Operator(eqns, opt='noop')
op1 = Operator(eqns, opt='buffering')
# Check generated code
assert len(retrieve_iteration_tree(op1)) == 2
buffers = [i for i in FindSymbols().visit(op1) if i.is_Array]
assert len(buffers) == 1
op0.apply(time_m=1)
op1.apply(time_m=1, v=v1)
assert | np.all(v.data == v1.data) | numpy.all |
'''
episodestats.py
implements statistic that are used in producing employment statistics for the
lifecycle model
'''
import h5py
import numpy as np
import numpy_financial as npf
import matplotlib.pyplot as plt
import matplotlib as mpl
import seaborn as sns
from scipy.stats import norm
#import locale
from tabulate import tabulate
import pandas as pd
import scipy.optimize
from tqdm import tqdm_notebook as tqdm
from . empstats import Empstats
from scipy.stats import gaussian_kde
#locale.setlocale(locale.LC_ALL, 'fi_FI')
def modify_offsettext(ax,text):
'''
For y axis
'''
x_pos = 0.0
y_pos = 1.0
horizontalalignment='left'
verticalalignment='bottom'
offset = ax.yaxis.get_offset_text()
#value=offset.get_text()
# value=float(value)
# if value>=1e12:
# text='biljoonaa'
# elif value>1e9:
# text=str(value/1e9)+' miljardia'
# elif value==1e9:
# text=' miljardia'
# elif value>1e6:
# text=str(value/1e6)+' miljoonaa'
# elif value==1e6:
# text='miljoonaa'
# elif value>1e3:
# text=str(value/1e3)+' tuhatta'
# elif value==1e3:
# text='tuhatta'
offset.set_visible(False)
ax.text(x_pos, y_pos, text, transform=ax.transAxes,
horizontalalignment=horizontalalignment,
verticalalignment=verticalalignment)
class Labels():
def get_labels(self,language='English'):
labels={}
if language=='English':
labels['osuus tilassa x']='Proportion in state {} [%]'
labels['age']='Age [y]'
labels['ratio']='Proportion [%]'
labels['unemp duration']='Length of unemployment [y]'
labels['scaled freq']='Scaled frequency'
labels['probability']='probability'
labels['telp']='Employee pension premium'
labels['sairausvakuutus']='Health insurance'
labels['työttömyysvakuutusmaksu']='Unemployment insurance'
labels['puolison verot']='Partners taxes'
labels['taxes']='Taxes'
labels['asumistuki']='Housing benefit'
labels['toimeentulotuki']='Supplementary benefit'
labels['tyottomyysturva']='Unemployment benefit'
labels['paivahoito']='Daycare'
labels['elake']='Pension'
labels['tyollisyysaste']='Employment rate'
labels['tyottomien osuus']='Proportion of unemployed'
labels['havainto']='Observation'
labels['tyottomyysaste']='Unemployment rate [%]'
labels['tyottomien osuus']='Proportion of unemployed [%]'
labels['tyollisyysaste %']='Employment rate [%]'
labels['ero osuuksissa']='Difference in proportions [%]'
labels['osuus']='proportion'
labels['havainto, naiset']='data, women'
labels['havainto, miehet']='data, men'
labels['palkkasumma']='Palkkasumma [euroa]'
labels['Verokiila %']='Verokiila [%]'
labels['Työnteko [hlö/htv]']='Työnteko [hlö/htv]'
labels['Työnteko [htv]']='Työnteko [htv]'
labels['Työnteko [hlö]']='Työnteko [hlö]'
labels['Työnteko [miljoonaa hlö/htv]']='Työnteko [miljoonaa hlö/htv]'
labels['Työnteko [miljoonaa htv]']='Työnteko [miljoonaa htv]'
labels['Työnteko [miljoonaa hlö]']='Työnteko [miljoonaa hlö]'
labels['Osatyönteko [%-yks]']='Osa-aikatyössä [%-yks]'
labels['Muut tulot [euroa]']='Muut tulot [euroa]'
labels['Henkilöitä']='Henkilöitä'
labels['Verot [euroa]']='Verot [euroa]'
labels['Verot [[miljardia euroa]']='Verot [[miljardia euroa]'
labels['Verokertymä [euroa]']='Verokertymä [euroa]'
labels['Verokertymä [miljardia euroa]']='Verokertymä [miljardia euroa]'
labels['Muut tarvittavat tulot [euroa]']='Muut tarvittavat tulot [euroa]'
labels['Muut tarvittavat tulot [miljardia euroa]']='Muut tarvittavat tulot [miljardia euroa]'
labels['malli']='Life cycle model'
else:
labels['osuus tilassa x']='Osuus tilassa {} [%]'
labels['age']='Ikä [v]'
labels['ratio']='Osuus tilassa [%]'
labels['unemp duration']='työttömyysjakson pituus [v]'
labels['scaled freq']='skaalattu taajuus'
labels['probability']='todennäköisyys'
labels['telp']='TEL-P'
labels['sairausvakuutus']='Sairausvakuutus'
labels['työttömyysvakuutusmaksu']='Työttömyysvakuutusmaksu'
labels['puolison verot']='puolison verot'
labels['taxes']='Verot'
labels['asumistuki']='Asumistuki'
labels['toimeentulotuki']='Toimeentulotuki'
labels['tyottomyysturva']='Työttömyysturva'
labels['paivahoito']='Päivähoito'
labels['elake']='Eläke'
labels['tyollisyysaste']='työllisyysaste'
labels['tyottomien osuus']='työttömien osuus'
labels['havainto']='havainto'
labels['tyottomyysaste']='Työttömyysaste [%]'
labels['tyottomien osuus']='Työttömien osuus väestöstö [%]'
labels['tyollisyysaste %']='Työllisyysaste [%]'
labels['ero osuuksissa']='Ero osuuksissa [%]'
labels['osuus']='Osuus'
labels['havainto, naiset']='havainto, naiset'
labels['havainto, miehet']='havainto, miehet'
labels['palkkasumma']='Palkkasumma [euroa]'
labels['Verokiila %']='Verokiila [%]'
labels['Työnteko [hlö/htv]']='Työnteko [hlö/htv]'
labels['Työnteko [htv]']='Työnteko [htv]'
labels['Työnteko [hlö]']='Työnteko [hlö]'
labels['Työnteko [miljoonaa hlö/htv]']='Työnteko [miljoonaa hlö/htv]'
labels['Työnteko [miljoonaa htv]']='Työnteko [miljoonaa htv]'
labels['Työnteko [miljoonaa hlö]']='Työnteko [miljoonaa hlö]'
labels['Osatyönteko [%-yks]']='Osa-aikatyössä [%-yks]'
labels['Muut tulot [euroa]']='Muut tulot [euroa]'
labels['Henkilöitä']='Henkilöitä'
labels['Verot [euroa]']='Verot [euroa]'
labels['Verot [[miljardia euroa]']='Verot [[miljardia euroa]'
labels['Verokertymä [euroa]']='Verokertymä [euroa]'
labels['Verokertymä [miljardia euroa]']='Verokertymä [miljardia euroa]'
labels['Muut tarvittavat tulot [euroa]']='Muut tarvittavat tulot [euroa]'
labels['Muut tarvittavat tulot [miljardia euroa]']='Muut tarvittavat tulot [miljardia euroa]'
labels['malli']='elinkaarimalli'
return labels
class EpisodeStats():
def __init__(self,timestep,n_time,n_emps,n_pop,env,minimal,min_age,max_age,min_retirementage,year=2018,version=3,params=None,gamma=0.92,lang='English'):
self.version=version
self.gamma=gamma
self.params=params
self.lab=Labels()
self.reset(timestep,n_time,n_emps,n_pop,env,minimal,min_age,max_age,min_retirementage,year,params=params,lang=lang)
print('version',version)
def reset(self,timestep,n_time,n_emps,n_pop,env,minimal,min_age,max_age,min_retirementage,year,version=None,params=None,lang=None,dynprog=False):
self.min_age=min_age
self.max_age=max_age
self.min_retirementage=min_retirementage
self.minimal=minimal
if params is not None:
self.params=params
if lang is None:
self.language='English'
else:
self.language=lang
if version is not None:
self.version=version
self.setup_labels()
self.n_employment=n_emps
self.n_time=n_time
self.timestep=timestep # 0.25 = 3kk askel
self.inv_timestep=int(np.round(1/self.timestep)) # pitää olla kokonaisluku
self.n_pop=n_pop
self.year=year
self.env=env
self.reaalinen_palkkojenkasvu=0.016
self.palkkakerroin=(0.8*1+0.2*1.0/(1+self.reaalinen_palkkojenkasvu))**self.timestep
self.elakeindeksi=(0.2*1+0.8*1.0/(1+self.reaalinen_palkkojenkasvu))**self.timestep
self.dynprog=dynprog
if self.minimal:
self.version=0
if self.version in set([0,101]):
self.n_groups=1
else:
self.n_groups=6
self.empstats=Empstats(year=self.year,max_age=self.max_age,n_groups=self.n_groups,timestep=self.timestep,n_time=self.n_time,
min_age=self.min_age)
self.init_variables()
def init_variables(self):
n_emps=self.n_employment
self.empstate=np.zeros((self.n_time,n_emps))
self.gempstate=np.zeros((self.n_time,n_emps,self.n_groups))
self.deceiced=np.zeros((self.n_time,1))
self.alive=np.zeros((self.n_time,1))
self.galive=np.zeros((self.n_time,self.n_groups))
self.rewstate=np.zeros((self.n_time,n_emps))
self.poprewstate=np.zeros((self.n_time,self.n_pop))
self.salaries_emp=np.zeros((self.n_time,n_emps))
#self.salaries=np.zeros((self.n_time,self.n_pop))
self.actions=np.zeros((self.n_time,self.n_pop))
self.popempstate=np.zeros((self.n_time,self.n_pop))
self.popunemprightleft=np.zeros((self.n_time,self.n_pop))
self.popunemprightused=np.zeros((self.n_time,self.n_pop))
self.tyoll_distrib_bu=np.zeros((self.n_time,self.n_pop))
self.unemp_distrib_bu=np.zeros((self.n_time,self.n_pop))
self.siirtyneet=np.zeros((self.n_time,n_emps))
self.siirtyneet_det=np.zeros((self.n_time,n_emps,n_emps))
self.pysyneet=np.zeros((self.n_time,n_emps))
self.aveV=np.zeros((self.n_time,self.n_pop))
self.time_in_state=np.zeros((self.n_time,n_emps))
self.stat_tyoura=np.zeros((self.n_time,n_emps))
self.stat_toe=np.zeros((self.n_time,n_emps))
self.stat_pension=np.zeros((self.n_time,n_emps))
self.stat_paidpension=np.zeros((self.n_time,n_emps))
self.out_of_work=np.zeros((self.n_time,n_emps))
self.stat_unemp_len=np.zeros((self.n_time,self.n_pop))
self.stat_wage_reduction=np.zeros((self.n_time,n_emps))
self.stat_wage_reduction_g=np.zeros((self.n_time,n_emps,self.n_groups))
self.infostats_group=np.zeros((self.n_pop,1))
self.infostats_taxes=np.zeros((self.n_time,1))
self.infostats_wagetaxes=np.zeros((self.n_time,1))
self.infostats_taxes_distrib=np.zeros((self.n_time,n_emps))
self.infostats_etuustulo=np.zeros((self.n_time,1))
self.infostats_etuustulo_group=np.zeros((self.n_time,self.n_groups))
self.infostats_perustulo=np.zeros((self.n_time,1))
self.infostats_palkkatulo=np.zeros((self.n_time,1))
self.infostats_palkkatulo_eielakkeella=np.zeros((self.n_time,1))
self.infostats_palkkatulo_group=np.zeros((self.n_time,self.n_groups))
self.infostats_palkkatulo_eielakkeella_group=np.zeros((self.n_time,1))
self.infostats_ansiopvraha=np.zeros((self.n_time,1))
self.infostats_ansiopvraha_group=np.zeros((self.n_time,self.n_groups))
self.infostats_asumistuki=np.zeros((self.n_time,1))
self.infostats_asumistuki_group=np.zeros((self.n_time,self.n_groups))
self.infostats_valtionvero=np.zeros((self.n_time,1))
self.infostats_valtionvero_group=np.zeros((self.n_time,self.n_groups))
self.infostats_kunnallisvero=np.zeros((self.n_time,1))
self.infostats_kunnallisvero_group=np.zeros((self.n_time,self.n_groups))
self.infostats_valtionvero_distrib=np.zeros((self.n_time,n_emps))
self.infostats_kunnallisvero_distrib=np.zeros((self.n_time,n_emps))
self.infostats_ptel=np.zeros((self.n_time,1))
self.infostats_tyotvakmaksu=np.zeros((self.n_time,1))
self.infostats_tyoelake=np.zeros((self.n_time,1))
self.infostats_kokoelake=np.zeros((self.n_time,1))
self.infostats_opintotuki=np.zeros((self.n_time,1))
self.infostats_isyyspaivaraha=np.zeros((self.n_time,1))
self.infostats_aitiyspaivaraha=np.zeros((self.n_time,1))
self.infostats_kotihoidontuki=np.zeros((self.n_time,1))
self.infostats_sairauspaivaraha=np.zeros((self.n_time,1))
self.infostats_toimeentulotuki=np.zeros((self.n_time,1))
self.infostats_tulot_netto=np.zeros((self.n_time,1))
self.infostats_pinkslip=np.zeros((self.n_time,n_emps))
self.infostats_pop_pinkslip=np.zeros((self.n_time,self.n_pop))
self.infostats_chilren18_emp=np.zeros((self.n_time,n_emps))
self.infostats_chilren7_emp=np.zeros((self.n_time,n_emps))
self.infostats_chilren18=np.zeros((self.n_time,1))
self.infostats_chilren7=np.zeros((self.n_time,1))
self.infostats_tyelpremium=np.zeros((self.n_time,self.n_pop))
self.infostats_paid_tyel_pension=np.zeros((self.n_time,self.n_pop))
self.infostats_sairausvakuutus=np.zeros((self.n_time))
self.infostats_pvhoitomaksu=np.zeros((self.n_time,self.n_pop))
self.infostats_ylevero=np.zeros((self.n_time,1))
self.infostats_ylevero_distrib=np.zeros((self.n_time,n_emps))
self.infostats_irr=np.zeros((self.n_pop,1))
self.infostats_npv0=np.zeros((self.n_pop,1))
self.infostats_mother_in_workforce=np.zeros((self.n_time,1))
self.infostats_children_under3=np.zeros((self.n_time,self.n_pop))
self.infostats_children_under7=np.zeros((self.n_time,self.n_pop))
self.infostats_unempwagebasis=np.zeros((self.n_time,self.n_pop))
self.infostats_unempwagebasis_acc=np.zeros((self.n_time,self.n_pop))
self.infostats_toe=np.zeros((self.n_time,self.n_pop))
self.infostats_ove=np.zeros((self.n_time,n_emps))
self.infostats_kassanjasen=np.zeros((self.n_time))
self.infostats_poptulot_netto=np.zeros((self.n_time,self.n_pop))
self.infostats_pop_wage=np.zeros((self.n_time,self.n_pop))
self.infostats_pop_pension=np.zeros((self.n_time,self.n_pop))
self.infostats_equivalent_income=np.zeros(self.n_time)
self.infostats_alv=np.zeros(self.n_time)
self.infostats_puoliso=np.zeros(self.n_time)
self.pop_predrew=np.zeros((self.n_time,self.n_pop))
if self.version==101:
self.infostats_savings=np.zeros((self.n_time,self.n_pop))
self.sav_actions=np.zeros((self.n_time,self.n_pop))
def add(self,n,act,r,state,newstate,q=None,debug=False,plot=False,aveV=None,pred_r=None):
if self.version==0:
emp,_,_,a,_,_=self.env.state_decode(state) # current employment state
newemp,newpen,newsal,a2,tis,next_wage=self.env.state_decode(newstate)
g=0
bu=0
ove=0
jasen=0
puoliso=0
elif self.version==1:
# v1
emp,_,_,_,a,_,_,_,_,_,_,_,_,_=self.env.state_decode(state) # current employment state
newemp,g,newpen,newsal,a2,tis,paidpens,pink,toe,ura,oof,bu,wr,p=self.env.state_decode(newstate)
ove=0
jasen=0
puoliso=0
elif self.version==2:
# v2
emp,_,_,_,a,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_=self.env.state_decode(state) # current employment state
newemp,g,newpen,newsal,a2,tis,paidpens,pink,toe,ura,bu,wr,upr,uw,uwr,pr,c3,c7,c18,unemp_left,aa,toe58=self.env.state_decode(newstate)
ove=0
jasen=0
puoliso=0
elif self.version==3:
# v3
emp,_,_,_,a,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_=self.env.state_decode(state) # current employment state
newemp,g,newpen,newsal,a2,tis,paidpens,pink,toe,toek,ura,bu,wr,upr,uw,uwr,pr,c3,c7,c18,unemp_left,aa,toe58,ove,jasen=self.env.state_decode(newstate)
puoliso=0
elif self.version==4:
# v3
emp,_,_,_,a,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_=self.env.state_decode(state) # current employment state
newemp,g,newpen,newsal,a2,tis,paidpens,pink,toe,toek,ura,bu,wr,upr,uw,uwr,pr,\
c3,c7,c18,unemp_left,aa,toe58,ove,jasen,puoliso,puoliso_tyossa,puoliso_palkka=self.env.state_decode(newstate)
elif self.version==101:
emp,_,_,a,_,_,_=self.env.state_decode(state) # current employment state
newemp,newpen,newsal,a2,tis,next_wage,savings=self.env.state_decode(newstate)
g=0
bu=0
ove=0
jasen=0
t=int(np.round((a2-self.min_age)*self.inv_timestep))#-1
if a2>a and newemp>=0: # new state is not reset (age2>age)
if a2>self.min_retirementage and newemp==3 and self.version in set([1,2,3,4]):
newemp=2
if self.version in set([1,2,3,4]):
self.empstate[t,newemp]+=1
self.alive[t]+=1
self.rewstate[t,newemp]+=r
self.poprewstate[t,n]=r
self.actions[t,n]=act
self.popempstate[t,n]=newemp
#self.salaries[t,n]=newsal
self.salaries_emp[t,newemp]+=newsal
self.time_in_state[t,newemp]+=tis
if tis<=0.25 and newemp==5:
self.infostats_mother_in_workforce[t]+=1
self.infostats_pinkslip[t,newemp]+=pink
self.infostats_pop_pinkslip[t,n]=pink
self.gempstate[t,newemp,g]+=1
self.stat_wage_reduction[t,newemp]+=wr
self.stat_wage_reduction_g[t,newemp,g]+=wr
self.galive[t,g]+=1
self.stat_tyoura[t,newemp]+=ura
self.stat_toe[t,newemp]+=toe
self.stat_pension[t,newemp]+=newpen
self.stat_paidpension[t,newemp]+=paidpens
self.stat_unemp_len[t,n]=tis
self.popunemprightleft[t,n]=-self.env.unempright_left(newemp,tis,bu,a2,ura)
self.popunemprightused[t,n]=bu
self.infostats_group[n]=int(g)
self.infostats_unempwagebasis[t,n]=uw
self.infostats_unempwagebasis_acc[t,n]=uwr
self.infostats_toe[t,n]=toe
self.infostats_ove[t,newemp]+=ove
self.infostats_kassanjasen[t]+=jasen
self.infostats_pop_wage[t,n]=newsal
self.infostats_pop_pension[t,n]=newpen
self.infostats_puoliso[t]+=puoliso
if q is not None:
#print(newsal,q['palkkatulot'])
self.infostats_taxes[t]+=q['verot']*self.timestep*12
self.infostats_wagetaxes[t]+=q['verot_ilman_etuuksia']*self.timestep*12
self.infostats_taxes_distrib[t,newemp]+=q['verot']*self.timestep*12
self.infostats_etuustulo[t]+=q['etuustulo_brutto']*self.timestep*12
self.infostats_etuustulo_group[t,g]+=q['etuustulo_brutto']*self.timestep*12
self.infostats_perustulo[t]+=q['perustulo']*self.timestep*12
self.infostats_palkkatulo[t]+=q['palkkatulot']*self.timestep*12
self.infostats_palkkatulo_eielakkeella[t]+=q['palkkatulot_eielakkeella']*self.timestep*12
self.infostats_ansiopvraha[t]+=q['ansiopvraha']*self.timestep*12
self.infostats_asumistuki[t]+=q['asumistuki']*self.timestep*12
self.infostats_valtionvero[t]+=q['valtionvero']*self.timestep*12
self.infostats_valtionvero_distrib[t,newemp]+=q['valtionvero']*self.timestep*12
self.infostats_kunnallisvero[t]+=q['kunnallisvero']*self.timestep*12
self.infostats_kunnallisvero_distrib[t,newemp]+=q['kunnallisvero']*self.timestep*12
self.infostats_ptel[t]+=q['ptel']*self.timestep*12
self.infostats_tyotvakmaksu[t]+=q['tyotvakmaksu']*self.timestep*12
self.infostats_tyoelake[t]+=q['elake_maksussa']*self.timestep*12
self.infostats_kokoelake[t]+=q['kokoelake']*self.timestep*12
self.infostats_opintotuki[t]+=q['opintotuki']*self.timestep*12
self.infostats_isyyspaivaraha[t]+=q['isyyspaivaraha']*self.timestep*12
self.infostats_aitiyspaivaraha[t]+=q['aitiyspaivaraha']*self.timestep*12
self.infostats_kotihoidontuki[t]+=q['kotihoidontuki']*self.timestep*12
self.infostats_sairauspaivaraha[t]+=q['sairauspaivaraha']*self.timestep*12
self.infostats_toimeentulotuki[t]+=q['toimtuki']*self.timestep*12
self.infostats_tulot_netto[t]+=q['kateen']*self.timestep*12
self.infostats_tyelpremium[t,n]=q['tyel_kokomaksu']*self.timestep*12
self.infostats_paid_tyel_pension[t,n]=q['puhdas_tyoelake']*self.timestep*12
self.infostats_sairausvakuutus[t]+=q['sairausvakuutus']*self.timestep*12
self.infostats_pvhoitomaksu[t,n]=q['pvhoito']*self.timestep*12
self.infostats_ylevero[t]+=q['ylevero']*self.timestep*12
self.infostats_ylevero_distrib[t,newemp]=q['ylevero']*self.timestep*12
self.infostats_poptulot_netto[t,n]=q['kateen']*self.timestep*12
self.infostats_children_under3[t,n]=c3
self.infostats_children_under7[t,n]=c7
self.infostats_npv0[n]=q['multiplier']
self.infostats_equivalent_income[t]+=q['eq']
if 'alv' in q:
self.infostats_alv[t]+=q['alv']
#self.infostats_kassanjasen[t]+=1
elif self.version in set([0,101]):
self.empstate[t,newemp]+=1
self.alive[t]+=1
self.rewstate[t,newemp]+=r
self.infostats_tulot_netto[t]+=q['netto'] # already at annual level
self.infostats_poptulot_netto[t,n]=q['netto']
self.poprewstate[t,n]=r
self.popempstate[t,n]=newemp
#self.salaries[t,n]=newsal
self.salaries_emp[t,newemp]+=newsal
self.time_in_state[t,newemp]+=tis
self.infostats_equivalent_income[t]+=q['eq']
self.infostats_pop_wage[t,n]=newsal
self.infostats_pop_pension[t,n]=newpen
if self.dynprog and pred_r is not None:
self.pop_predrew[t,n]=pred_r
if self.version==101:
self.infostats_savings[t,n]=savings
self.actions[t,n]=act[0]
self.sav_actions[t,n]=act[1]
else:
self.actions[t,n]=act
# if self.version in set([1,2,3]):
# self.gempstate[t,newemp,g]+=1
# self.stat_wage_reduction[t,newemp]+=wr
# self.galive[t,g]+=1
# self.stat_tyoura[t,newemp]+=ura
# self.stat_toe[t,newemp]+=toe
# self.stat_pension[t,newemp]+=newpen
# self.stat_paidpension[t,newemp]+=paidpens
# self.stat_unemp_len[t,n]=tis
# self.popunemprightleft[t,n]=0
# self.popunemprightused[t,n]=0
if aveV is not None:
self.aveV[t,n]=aveV
if not emp==newemp:
self.siirtyneet[t,emp]+=1
self.siirtyneet_det[t,emp,newemp]+=1
else:
self.pysyneet[t,emp]+=1
elif newemp<0:
self.deceiced[t]+=1
def scale_error(self,x,target=None,averaged=False):
return (target-self.comp_scaled_consumption(x,averaged=averaged))
def comp_employed_ratio_by_age(self,emp=None,grouped=False,g=0):
if emp is None:
if grouped:
emp=np.squeeze(self.gempstate[:,:,g])
else:
emp=self.empstate
nn=np.sum(emp,1)
if self.minimal:
tyoll_osuus=(emp[:,1]+emp[:,3])/nn
htv_osuus=(emp[:,1]+0.5*emp[:,3])/nn
tyoll_osuus=np.reshape(tyoll_osuus,(tyoll_osuus.shape[0],1))
htv_osuus=np.reshape(htv_osuus,(htv_osuus.shape[0],1))
else:
# työllisiksi lasketaan kokoaikatyössä olevat, osa-aikaiset, ve+työ, ve+osatyö
# isyysvapaalla olevat jötetty pois, vaikka vapaa kestöö alle 3kk
tyoll_osuus=(emp[:,1]+emp[:,8]+emp[:,9]+emp[:,10])
htv_osuus=(emp[:,1]+0.5*emp[:,8]+emp[:,9]+0.5*emp[:,10])
tyoll_osuus=np.reshape(tyoll_osuus,(tyoll_osuus.shape[0],1))
htv_osuus=np.reshape(htv_osuus,(htv_osuus.shape[0],1))
return tyoll_osuus,htv_osuus
def comp_employed_aggregate(self,emp=None,start=20,end=63.5,grouped=False,g=0):
if emp is None:
if grouped:
emp=self.gempstate[:,:,g]
else:
emp=self.empstate
nn=np.sum(emp,1)
if self.minimal:
tyoll_osuus=(emp[:,1]+emp[:,3])/nn
htv_osuus=(emp[:,1]+0.5*emp[:,3])/nn
else:
# työllisiksi lasketaan kokoaikatyössä olevat, osa-aikaiset, ve+työ, ve+osatyö
# isyysvapaalla olevat jötetty pois, vaikka vapaa kestöö alle 3kk
tyoll_osuus=(emp[:,1]+emp[:,8]+emp[:,9]+emp[:,10])/nn
htv_osuus=(emp[:,1]+0.5*emp[:,8]+emp[:,9]+0.5*emp[:,10])/nn
htv_osuus=self.comp_state_stats(htv_osuus,start=start,end=end,ratio=True)
tyoll_osuus=self.comp_state_stats(tyoll_osuus,start=start,end=end,ratio=True)
return tyoll_osuus,htv_osuus
def comp_group_ps(self):
return self.comp_palkkasumma(grouped=True)
def comp_palkkasumma(self,start=19,end=68,grouped=False,scale_time=True):
demog2=self.empstats.get_demog()
if scale_time:
scale=self.timestep
else:
scale=1.0
min_cage=self.map_age(start)
max_cage=self.map_age(end)+1
if grouped:
scalex=demog2/self.n_pop*self.timestep
ps=np.zeros((self.n_time,6))
ps_norw=np.zeros((self.n_time,6))
a_ps=np.zeros(6)
a_ps_norw=np.zeros(6)
for k in range(self.n_pop):
g=int(self.infostats_group[k,0])
for t in range(min_cage,max_cage):
e=int(self.popempstate[t,k])
if e in set([1,10]):
ps[t,g]+=self.infostats_pop_wage[t,k]
ps_norw[t,g]+=self.infostats_pop_wage[t,k]
elif e in set([8,9]):
ps[t,g]+=self.infostats_pop_wage[t,k]*self.timestep
for g in range(6):
a_ps[g]=np.sum(scalex[min_cage:max_cage]*ps[min_cage:max_cage,g])
a_ps_norw[g]=np.sum(scalex[min_cage:max_cage]*ps_norw[min_cage:max_cage,g])
else:
scalex=demog2/self.n_pop*self.timestep
ps=np.zeros((self.n_time,1))
ps_norw=np.zeros((self.n_time,1))
for k in range(self.n_pop):
for t in range(min_cage,max_cage):
e=int(self.popempstate[t,k])
if e in set([1,10]):
ps[t,0]+=self.infostats_pop_wage[t,k]
ps_norw[t,0]+=self.infostats_pop_wage[t,k]
elif e in set([8,9]):
ps[t,0]+=self.infostats_pop_wage[t,k]
a_ps=np.sum(scalex[min_cage:max_cage]*ps[min_cage:max_cage])
a_ps_norw=np.sum(scalex[min_cage:max_cage]*ps_norw[min_cage:max_cage])
return a_ps,a_ps_norw
def comp_stats_agegroup(self,border=[19,35,50]):
n_groups=len(border)
low=border.copy()
high=border.copy()
high[0:n_groups-1]=border[1:n_groups]
high[-1]=65
employed=np.zeros(n_groups)
unemployed=np.zeros(n_groups)
ahtv=np.zeros(n_groups)
parttimeratio=np.zeros(n_groups)
unempratio=np.zeros(n_groups)
empratio=np.zeros(n_groups)
i_ps=np.zeros(n_groups)
i_ps_norw=np.zeros(n_groups)
for n in range(n_groups):
l=low[n]
h=high[n]
htv,tyollvaikutus,tyollaste,tyotosuus,tyottomat,osatyollaste=\
self.comp_tyollisyys_stats(self.empstate,scale_time=True,start=l,end=h,agegroups=True)
ps,ps_norw=self.comp_palkkasumma(start=l,end=h)
print(f'l {l} h {h}\nhtv {htv}\ntyollaste {tyollaste}\ntyotosuus {tyotosuus}\ntyottomat {tyottomat}\nosatyollaste {osatyollaste}\nps {ps}')
employed[n]=tyollvaikutus
ahtv[n]=htv
unemployed[n]=tyottomat
unempratio[n]=tyotosuus
empratio[n]=tyollaste
parttimeratio[n]=osatyollaste
i_ps[n]=ps
i_ps_norw[n]=ps_norw
return employed,ahtv,unemployed,parttimeratio,i_ps,i_ps_norw,unempratio,empratio
def comp_unemployed_ratio_by_age(self,emp=None,grouped=False,g=0):
if emp is None:
if grouped:
emp=self.gempstate[:,:,g]
else:
emp=self.empstate
nn=np.sum(emp,1)
if self.minimal:
tyot_osuus=emp[:,0]/nn
tyot_osuus=np.reshape(tyot_osuus,(tyot_osuus.shape[0],1))
else:
# työllisiksi lasketaan kokoaikatyössä olevat, osa-aikaiset, ve+työ, ve+osatyö
# isyysvapaalla olevat jötetty pois, vaikka vapaa kestöö alle 3kk
tyot_osuus=(emp[:,0]+emp[:,4]+emp[:,13])[:,None]
#tyot_osuus=np.reshape(tyot_osuus,(tyot_osuus.shape[0],1))
return tyot_osuus
def comp_unemployed_aggregate(self,emp=None,start=20,end=63.5,scale_time=True,grouped=False,g=0):
if emp is None:
if grouped:
emp=self.gempstate[:,:,g]
else:
emp=self.empstate
nn=np.sum(emp,1)
if self.minimal:
tyot_osuus=emp[:,0]/nn
else:
tyot_osuus=(emp[:,0]+emp[:,4]+emp[:,13])/nn
#print(f'tyot_osuus {tyot_osuus}')
unemp=self.comp_state_stats(tyot_osuus,start=start,end=end,ratio=True)
return unemp
def comp_parttime_aggregate(self,emp=None,start=20,end=63.5,scale_time=True,grouped=False,g=0):
'''
Lukumäärätiedot (EI HTV!)
'''
if emp is None:
if grouped:
emp=self.gempstate[:,:,g]
else:
emp=self.empstate
nn=np.sum(emp,1)
if not self.minimal:
tyossa=(emp[:,1]+emp[:,10]+emp[:,8]+emp[:,9])/nn
osatyossa=(emp[:,10]+emp[:,8])/nn
else:
tyossa=emp[:,1]/nn
osatyossa=0*tyossa
osatyo_osuus=osatyossa/tyossa
osatyo_osuus=self.comp_state_stats(osatyo_osuus,start=start,end=end,ratio=True)
kokotyo_osuus=1-osatyo_osuus
return kokotyo_osuus,osatyo_osuus
def comp_parttime_ratio_by_age(self,emp=None,grouped=False,g=0):
if emp is None:
if grouped:
emp=self.gempstate[:,:,g]
else:
emp=self.empstate
nn=np.sum(emp,1)
if self.minimal:
kokotyo_osuus=(emp[:,1])/nn
osatyo_osuus=(emp[:,3])/nn
else:
if grouped:
for g in range(6):
kokotyo_osuus=(emp[:,1,g]+emp[:,9,g])/nn
osatyo_osuus=(emp[:,8,g]+emp[:,10,g])/nn
else:
kokotyo_osuus=(emp[:,1]+emp[:,9])/nn
osatyo_osuus=(emp[:,8]+emp[:,10])/nn
osatyo_osuus=np.reshape(osatyo_osuus,(osatyo_osuus.shape[0],1))
kokotyo_osuus=np.reshape(kokotyo_osuus,(osatyo_osuus.shape[0],1))
return kokotyo_osuus,osatyo_osuus
def comp_employed_ratio(self,emp):
tyoll_osuus,htv_osuus=self.comp_employed_ratio_by_age(emp)
tyot_osuus=self.comp_unemployed_ratio_by_age(emp)
kokotyo_osuus,osatyo_osuus=self.comp_parttime_ratio_by_age(emp)
return tyoll_osuus,htv_osuus,tyot_osuus,kokotyo_osuus,osatyo_osuus
def comp_unemployed_detailed(self,emp):
if self.minimal:
ansiosid_osuus=emp[:,0]/np.sum(emp,1)
tm_osuus=ansiosid_osuus*0
else:
# työllisiksi lasketaan kokoaikatyössä olevat, osa-aikaiset, ve+työ, ve+osatyö
# isyysvapaalla olevat jötetty pois, vaikka vapaa kestöö alle 3kk
ansiosid_osuus=(emp[:,0]+emp[:,4])/np.sum(emp,1)
tm_osuus=(emp[:,13])/np.sum(emp,1)
return ansiosid_osuus,tm_osuus
def comp_tyollisyys_stats(self,emp,scale_time=True,start=19,end=68,full=False,tyot_stats=False,agg=False,shapes=False,only_groups=False,g=0,agegroups=False):
demog2=self.empstats.get_demog()
if scale_time:
scale=self.timestep
else:
scale=1.0
min_cage=self.map_age(start)
max_cage=self.map_age(end)+1
scalex=demog2[min_cage:max_cage]/self.n_pop*scale
if only_groups:
tyollosuus,htvosuus,tyot_osuus,kokotyo_osuus,osatyo_osuus=self.comp_employed_ratio(emp)
else:
tyollosuus,htvosuus,tyot_osuus,kokotyo_osuus,osatyo_osuus=self.comp_employed_ratio(emp)
htv=np.sum(scalex*htvosuus[min_cage:max_cage])
tyollvaikutus=np.sum(scalex*tyollosuus[min_cage:max_cage])
tyottomat=np.sum(scalex*tyot_osuus[min_cage:max_cage])
osatyollvaikutus=np.sum(scalex*osatyo_osuus[min_cage:max_cage])
kokotyollvaikutus=np.sum(scalex*kokotyo_osuus[min_cage:max_cage])
haj=np.mean(np.std(tyollosuus[min_cage:max_cage]))
tyollaste=tyollvaikutus/(np.sum(scalex)*self.n_pop)
osatyollaste=osatyollvaikutus/(kokotyollvaikutus+osatyollvaikutus)
kokotyollaste=kokotyollvaikutus/(kokotyollvaikutus+osatyollvaikutus)
if tyot_stats:
if agg:
#d2=np.squeeze(demog2)
tyolliset_osuus=np.squeeze(tyollosuus)
tyottomat_osuus=np.squeeze(tyot_osuus)
return tyolliset_ika,tyottomat_ika,htv_ika,tyolliset_osuus,tyottomat_osuus
else:
d2=np.squeeze(demog2)
tyolliset_ika=np.squeeze(scale*d2*np.squeeze(htvosuus))
tyottomat_ika=np.squeeze(scale*d2*np.squeeze(tyot_osuus))
htv_ika=np.squeeze(scale*d2*np.squeeze(htvosuus))
tyolliset_osuus=np.squeeze(tyollosuus)
tyottomat_osuus=np.squeeze(tyot_osuus)
return tyolliset_ika,tyottomat_ika,htv_ika,tyolliset_osuus,tyottomat_osuus
elif full:
return htv,tyollvaikutus,haj,tyollaste,tyollosuus,osatyollvaikutus,kokotyollvaikutus,osatyollaste,kokotyollaste
elif agegroups:
tyot_osuus=self.comp_unemployed_aggregate(start=start,end=end)
return htv,tyollvaikutus,tyollaste,tyot_osuus,tyottomat,osatyollaste
else:
return htv,tyollvaikutus,haj,tyollaste,tyollosuus
def comp_employment_stats(self,scale_time=True,returns=False):
demog2=self.empstats.get_demog()
if scale_time:
scale=self.timestep
else:
scale=1.0
min_cage=self.map_age(self.min_age)
max_cage=self.map_age(self.max_age)+1
scalex=np.squeeze(demog2/self.n_pop*self.timestep)
d=np.squeeze(demog2[min_cage:max_cage])
self.ratiostates=self.empstate/self.alive
self.demogstates=(self.empstate.T*scalex).T
if self.minimal>0:
self.stats_employed=self.demogstates[:,0]+self.demogstates[:,3]
self.stats_parttime=self.demogstates[:,3]
self.stats_unemployed=self.demogstates[:,0]
self.stats_all=np.sum(self.demogstates,1)
else:
self.stats_employed=self.demogstates[:,0]+self.demogstates[:,10]+self.demogstates[:,8]+self.demogstates[:,9]
self.stats_parttime=self.demogstates[:,10]+self.demogstates[:,8]
self.stats_unemployed=self.demogstates[:,0]+self.demogstates[:,4]+self.demogstates[:,13]
self.stats_all=np.sum(self.demogstates,1)
if returns:
return self.stats_employed,self.stats_parttime,self.stats_unemployed
# def test_emp(self):
# g_emp=0
# g_htv=0
# g_10=0
# g_1=0
# g_8=0
# g_9=0
# g_x=0
# scalex=1
#
# demog2=self.empstats.get_demog()
# scalex=np.squeeze(demog2/self.n_pop*self.timestep)
#
#
# for g in range(6):
# q=self.comp_participants(grouped=True,g=g)
# #g_1+=np.sum(self.gempstate[:,1,g])
# #g_10+=np.sum(self.gempstate[:,10,g])
# #g_8+=np.sum(self.gempstate[:,8,g])
# #g_9+=np.sum(self.gempstate[:,9,g])
# g_emp+=q['palkansaajia']
# g_htv+=q['htv']
# g_x+=np.sum((self.gempstate[:,1,g]+self.gempstate[:,10,g])*scalex)
#
# q=self.comp_participants()
# s_1=np.sum(self.empstate[:,1])
# s_10=np.sum(self.empstate[:,10])
# s_8=np.sum(self.empstate[:,8])
# s_9=np.sum(self.empstate[:,9])
# s_x=np.sum((self.empstate[:,1]+self.empstate[:,10])*scalex)
# emp=q['palkansaajia']
# htv=q['htv']
#
# print(f'htv {htv} vs g_htv {g_htv}')
# print(f'emp {emp} vs g_emp {g_emp}')
# print(f's_x {s_x} vs g_x {g_x}')
# #print(f's_1 {s_1} vs g_1 {g_1}')
# #print(f's_10 {s_10} vs g_10 {g_10}')
# #print(f's_8 {s_8} vs g_8 {g_8}')
# #print(f's_9 {s_9} vs g_9 {g_9}')
def comp_participants(self,scale=True,include_retwork=True,grouped=False,g=0):
'''
<NAME> lkm
scalex olettaa, että naisia & miehiä yhtä paljon. Tämän voisi tarkentaa.
'''
demog2=self.empstats.get_demog()
scalex=np.squeeze(demog2/self.n_pop*self.timestep)
#print('version',self.version)
q={}
if self.version in set([1,2,3,4]):
if grouped:
#print('group=',g)
emp=np.squeeze(self.gempstate[:,:,g])
q['yhteensä']=np.sum(np.sum(emp,axis=1)*scalex)
if include_retwork:
q['palkansaajia']=np.sum((emp[:,1]+emp[:,10]+emp[:,8]+emp[:,9])*scalex)
q['htv']=np.sum((emp[:,1]+0.5*emp[:,10]+0.5*emp[:,8]+emp[:,9])*scalex)
else:
q['palkansaajia']=np.sum((emp[:,1]+emp[:,10])*scalex)
q['htv']=np.sum((emp[:,1]+0.5*emp[:,10])*scalex)
q['ansiosidonnaisella']=np.sum((emp[:,0]+emp[:,4])*scalex)
q['tmtuella']=np.sum(emp[:,13]*scalex)
q['isyysvapaalla']=np.sum(emp[:,6]*scalex)
q['kotihoidontuella']=np.sum(emp[:,7]*scalex)
q['vanhempainvapaalla']=np.sum(emp[:,5]*scalex)
else:
q['yhteensä']=np.sum(np.sum(self.empstate[:,:],axis=1)*scalex)
if include_retwork:
q['palkansaajia']=np.sum((self.empstate[:,1]+self.empstate[:,10]+self.empstate[:,8]+self.empstate[:,9])*scalex)
q['htv']=np.sum((self.empstate[:,1]+0.5*self.empstate[:,10]+0.5*self.empstate[:,8]+self.empstate[:,9])*scalex)
else:
q['palkansaajia']=np.sum((self.empstate[:,1]+self.empstate[:,10])*scalex)
q['htv']=np.sum((self.empstate[:,1]+0.5*self.empstate[:,10])*scalex)
q['ansiosidonnaisella']=np.sum((self.empstate[:,0]+self.empstate[:,4])*scalex)
q['tmtuella']=np.sum(self.empstate[:,13]*scalex)
q['isyysvapaalla']=np.sum(self.empstate[:,6]*scalex)
q['kotihoidontuella']=np.sum(self.empstate[:,7]*scalex)
q['vanhempainvapaalla']=np.sum(self.empstate[:,5]*scalex)
else:
q['yhteensä']=np.sum(np.sum(self.empstate[:,:],1)*scalex)
q['palkansaajia']=np.sum((self.empstate[:,1])*scalex)
q['htv']=np.sum((self.empstate[:,1])*scalex)
q['ansiosidonnaisella']=np.sum((self.empstate[:,0])*scalex)
q['tmtuella']=np.sum(self.empstate[:,1]*0)
q['isyysvapaalla']=np.sum(self.empstate[:,1]*0)
q['kotihoidontuella']=np.sum(self.empstate[:,1]*0)
q['vanhempainvapaalla']=np.sum(self.empstate[:,1]*0)
return q
def comp_employment_groupstats(self,scale_time=True,g=0,include_retwork=True,grouped=True):
demog2=self.empstats.get_demog()
if scale_time:
scale=self.timestep
else:
scale=1.0
#min_cage=self.map_age(self.min_age)
#max_cage=self.map_age(self.max_age)+1
scalex=np.squeeze(demog2/self.n_pop*scale)
#d=np.squeeze(demog2[min_cage:max_cage])
if grouped:
ratiostates=np.squeeze(self.gempstate[:,:,g])/self.alive
demogstates=np.squeeze(self.gempstate[:,:,g])
else:
ratiostates=self.empstate[:,:]/self.alive
demogstates=self.empstate[:,:]
if self.version in set([1,2,3,4]):
if include_retwork:
stats_employed=np.sum((demogstates[:,1]+demogstates[:,9])*scalex)
stats_parttime=np.sum((demogstates[:,10]+demogstates[:,8])*scalex)
else:
stats_employed=np.sum((demogstates[:,1])*scalex)
stats_parttime=np.sum((demogstates[:,10])*scalex)
stats_unemployed=np.sum((demogstates[:,0]+demogstates[:,4]+demogstates[:,13])*scalex)
else:
stats_employed=np.sum((demogstates[:,0]+demogstates[:,3])*scalex)
stats_parttime=np.sum((demogstates[:,3])*scalex)
stats_unemployed=np.sum((demogstates[:,0])*scalex)
#stats_all=np.sum(demogstates,1)
return stats_employed,stats_parttime,stats_unemployed
def comp_state_stats(self,state,scale_time=True,start=20,end=63.5,ratio=False):
demog2=np.squeeze(self.empstats.get_demog())
#if scale_time:
# scale=self.timestep
#else:
# scale=1.0
min_cage=self.map_age(start)
max_cage=self.map_age(end)+1
#vaikutus=np.round(scale*np.sum(demog2[min_cage:max_cage]*state[min_cage:max_cage]))/np.sum(demog2[min_cage:max_cage])
vaikutus=np.sum(demog2[min_cage:max_cage]*state[min_cage:max_cage])/np.sum(demog2[min_cage:max_cage])
x=np.sum(demog2[min_cage:max_cage]*state[min_cage:max_cage])
y=np.sum(demog2[min_cage:max_cage])
#print(f'vaikutus {vaikutus} x {x} y {y}\n s {state[min_cage:max_cage]} mean {np.mean(state[min_cage:max_cage])}\n d {demog2[min_cage:max_cage]}')
return vaikutus
def get_vanhempainvapaat(self):
'''
Laskee vanhempainvapaalla olevien määrän outsider-mallia (Excel) varten, tila 6
'''
alive=np.zeros((self.galive.shape[0],1))
alive[:,0]=np.sum(self.galive[:,0:3],1)
ulkopuolella_m=np.sum(self.gempstate[:,7,0:3],axis=1)[:,None]/alive
alive[:,0]=np.sum(self.galive[:,3:6],1)
nn=np.sum(self.gempstate[:,5,3:6]+self.gempstate[:,7,3:6],axis=1)[:,None]-self.infostats_mother_in_workforce
ulkopuolella_n=nn/alive
return ulkopuolella_m[::4],ulkopuolella_n[::4]
def get_vanhempainvapaat_md(self):
'''
Laskee vanhempainvapaalla olevien määrän outsider-mallia (Excel) varten, tila 7
'''
alive=np.zeros((self.galive.shape[0],1))
alive[:,0]=np.sum(self.galive[:,0:3],1)
ulkopuolella_m=np.sum(self.gempstate[:,6,0:3],axis=1)[:,None]/alive
alive[:,0]=np.sum(self.galive[:,3:6],1)
nn=self.infostats_mother_in_workforce
ulkopuolella_n=nn/alive
return ulkopuolella_m[::4],ulkopuolella_n[::4]
def comp_L2error(self):
tyollisyysaste_m,osatyoaste_m,tyottomyysaste_m,ka_tyottomyysaste=self.comp_gempratios(gender='men',unempratio=False)
tyollisyysaste_w,osatyoaste_w,tyottomyysaste_w,ka_tyottomyysaste=self.comp_gempratios(gender='women',unempratio=False)
emp_statsratio_m=self.empstats.emp_stats(g=1)[:-1]*100
emp_statsratio_w=self.empstats.emp_stats(g=2)[:-1]*100
unemp_statsratio_m=self.empstats.unemp_stats(g=1)[:-1]*100
unemp_statsratio_w=self.empstats.unemp_stats(g=2)[:-1]*100
w1=1.0
w2=3.0
L2= w1*np.sum(np.abs(emp_statsratio_m-tyollisyysaste_m[:-1])**2)+\
w1*np.sum(np.abs(emp_statsratio_w-tyollisyysaste_w[:-1])**2)+\
w2*np.sum(np.abs(unemp_statsratio_m-tyottomyysaste_m[:-1])**2)+\
w2*np.sum(np.abs(unemp_statsratio_w-tyottomyysaste_w[:-1])**2)
L2=L2/self.n_pop
#print(L1,emp_statsratio_m,tyollisyysaste_m,tyollisyysaste_w,unemp_statsratio_m,tyottomyysaste_m,tyottomyysaste_w)
print('L2 error {}'.format(L2))
return L2
def comp_budgetL2error(self,ref_muut,scale=1):
q=self.comp_budget()
muut=q['muut tulot']
L2=-((ref_muut-muut)/scale)**2
print(f'L2 error {L2} (muut {muut} muut_ref {ref_muut})')
return L2
def optimize_scale(self,target,averaged=scale_error):
opt=scipy.optimize.least_squares(self.scale_error,0.20,bounds=(-1,1),kwargs={'target':target,'averaged':averaged})
#print(opt)
return opt['x']
def optimize_logutil(self,target,source):
'''
analytical compensated consumption
does not implement final reward, hence duration 110 y
'''
n_time=110
gy=np.empty(n_time)
g=1
gx=np.empty(n_time)
for t in range(0,n_time):
gx[t]=g
g*=self.gamma
for t in range(1,n_time):
gy[t]=np.sum(gx[0:t])
gf=np.mean(gy[1:])/10
lx=(target-source)
opt=np.exp(lx/gf)-1.0
print(opt)
def min_max(self):
min_wage=np.min(self.infostats_pop_wage)
max_wage=np.max(self.infostats_pop_wage)
max_pension=np.max(self.infostats_pop_pension)
min_pension=np.min(self.infostats_pop_pension)
print(f'min wage {min_wage} max wage {max_wage}')
print(f'min pension {min_pension} max pension {max_pension}')
def setup_labels(self):
self.labels=self.lab.get_labels(self.language)
def map_age(self,age,start_zero=False):
if start_zero:
return int((age)*self.inv_timestep)
else:
return int((age-self.min_age)*self.inv_timestep)
def map_t_to_age(self,t):
return self.min_age+t/self.inv_timestep
def episodestats_exit(self):
plt.close(self.episode_fig)
def comp_gini(self):
'''
<NAME>-kerroin populaatiolle
'''
income=np.sort(self.infostats_tulot_netto,axis=None)
n=len(income)
L=np.arange(n,0,-1)
A=np.sum(L*income)/np.sum(income)
G=(n+1-2*A)/2
return G
def comp_annual_irr(self,npv,premium,pension,empstate,doprint=False):
k=0
max_npv=int(np.ceil(npv))
cashflow=-premium+pension
x=np.zeros(cashflow.shape[0]+max_npv)
eind=np.zeros(max_npv+1)
el=1
for k in range(max_npv+1):
eind[k]=el
el=el*self.elakeindeksi
x[:cashflow.shape[0]]=cashflow
if npv>0:
x[cashflow.shape[0]-1:]=cashflow[-2]*eind[:max_npv+1]
y=np.zeros(int(np.ceil(x.shape[0]/4)))
for k in range(y.shape[0]):
y[k]=np.sum(x[4*k:4*k+4])
irri=npf.irr(y)*100
#if np.isnan(irri):
# if np.sum(pension)<0.1 and np.sum(empstate[0:self.map_age(63)]==15)>0: # vain maksuja, joista ei saa tuottoja, joten tappio 100%
# irri=-100
if irri<0.01 and doprint:
print('---------\nirri {}\nnpv {}\nx {}\ny {}\nprem {}\npens {}\nemps {}\n---------\n'.format(irri,npv,x,y,premium,pension,empstate))
if irri>100 and doprint:
print('---------\nirri {}\nnpv {}\nx {}\ny {}\nprem {}\npens {}\nemps {}\n---------\n'.format(irri,npv,x,y,premium,pension,empstate))
if np.isnan(irri) and doprint:
print('---------\nirri {}\nnpv {}\nx {}\ny {}\nprem {}\npens {}\nemps {}\n---------\n'.format(irri,npv,x,y,premium,np.sum(pension),empstate))
#print('---------\nirri {}\nnpv {}\n\ny {}\nprem {}\npens {}\nemps {}\n---------\n'.format(irri,npv,x,y,premium,np.sum(pension),np.sum(empstate==15)))
if irri<-50 and doprint:
print('---------\nirri {}\nnpv {}\nx {}\ny {}\nprem {}\npens {}\nemps {}\n---------\n'.format(irri,npv,x,y,premium,pension,empstate))
return irri
def comp_irr(self):
'''
Laskee sisäisen tuottoasteen (IRR)
Indeksointi puuttuu npv:n osalta
Tuloksiin lisättävä inflaatio+palkkojen reaalikasvu = palkkojen nimellinen kasvu
'''
for k in range(self.n_pop):
self.infostats_irr[k]=self.reaalinen_palkkojenkasvu*100+self.comp_annual_irr(self.infostats_npv0[k,0],self.infostats_tyelpremium[:,k],self.infostats_paid_tyel_pension[:,k],self.popempstate[:,k])
def comp_aggirr(self):
'''
Laskee aggregoidun sisäisen tuottoasteen (IRR)
Indeksointi puuttuu npv:n osalta
Tuloksiin lisättävä inflaatio+palkkojen reaalikasvu = palkkojen nimellinen kasvu
'''
maxnpv=np.max(self.infostats_npv0)
agg_premium=np.sum(self.infostats_tyelpremium,axis=1)
agg_pensions=np.sum(self.infostats_paid_tyel_pension,axis=1)
agg_irr=self.reaalinen_palkkojenkasvu*100+self.comp_annual_irr(maxnpv,agg_premium,agg_pensions,self.popempstate[:,0])
x=np.zeros(self.infostats_paid_tyel_pension.shape[0]+int(np.ceil(maxnpv)))
max_npv=int(max(np.ceil(self.infostats_npv0[:,0])))
eind=np.zeros(max_npv)
el=1
for k in range(max_npv):
eind[k]=el
el=el*self.elakeindeksi
cfn=self.infostats_tyelpremium.shape[0]
for k in range(self.n_pop):
if np.sum(self.popempstate[0:self.map_age(63),k]==15)<1: # ilman kuolleita
n=int(np.ceil(self.infostats_npv0[k,0]))
cashflow=-self.infostats_tyelpremium[:,k]+self.infostats_paid_tyel_pension[:,k]
# indeksointi puuttuu
x[:cfn]+=cashflow
if n>0:
x[cfn-1:cfn+n-1]+=cashflow[-2]*eind[:n] # ei indeksoida, pitäisi huomioida takuueläkekin
y=np.zeros(int(np.ceil(x.shape[0]/4)))
for k in range(y.shape[0]):
y[k]=np.sum(x[4*k:4*k+101])
irri=npf.irr(y)*100
print('aggregate irr {}'.format(agg_irr))
def comp_unemp_durations(self,popempstate=None,popunemprightused=None,putki=True,\
tmtuki=False,laaja=False,outsider=False,ansiosid=True,tyott=False,kaikki=False,\
return_q=True,max_age=100):
'''
Poikkileikkaushetken työttömyyskestot
'''
unempset=[]
if tmtuki:
unempset.append(13)
if outsider:
unempset.append(11)
if putki:
unempset.append(4)
if ansiosid:
unempset.append(0)
if tyott:
unempset=[0,4,13]
if laaja:
unempset=[0,4,11,13]
if kaikki:
unempset=[0,2,3,4,5,6,7,8,9,11,12,13,14]
unempset=set(unempset)
if popempstate is None:
popempstate=self.popempstate
if popunemprightused is None:
popunemprightused=self.popunemprightused
keskikesto=np.zeros((5,5)) # 20-29, 30-39, 40-49, 50-59, 60-69, vastaa TYJin tilastoa
n=np.zeros(5)
for k in range(self.n_pop):
for t in range(1,self.n_time):
age=self.min_age+t*self.timestep
if age<=max_age:
if popempstate[t,k] in unempset:
if age<29:
l=0
elif age<39:
l=1
elif age<49:
l=2
elif age<59:
l=3
else:
l=4
n[l]+=1
if self.popunemprightused[t,k]<=0.51:
keskikesto[l,0]+=1
elif self.popunemprightused[t,k]<=1.01:
keskikesto[l,1]+=1
elif self.popunemprightused[t,k]<=1.51:
keskikesto[l,2]+=1
elif self.popunemprightused[t,k]<=2.01:
keskikesto[l,3]+=1
else:
keskikesto[l,4]+=1
for k in range(5):
keskikesto[k,:] /= n[k]
if return_q:
return self.empdur_to_dict(keskikesto)
else:
return keskikesto
def empdur_to_dict(self,empdur):
q={}
q['20-29']=empdur[0,:]
q['30-39']=empdur[1,:]
q['40-49']=empdur[2,:]
q['50-59']=empdur[3,:]
q['60-65']=empdur[4,:]
return q
def comp_unemp_durations_v2(self,popempstate=None,putki=True,tmtuki=False,laaja=False,\
outsider=False,ansiosid=True,tyott=False,kaikki=False,\
return_q=True,max_age=100):
'''
Poikkileikkaushetken työttömyyskestot
Tässä lasketaan tulos tiladatasta, jolloin kyse on viimeisimmän jakson kestosta
'''
unempset=[]
if tmtuki:
unempset.append(13)
if outsider:
unempset.append(11)
if putki:
unempset.append(4)
if ansiosid:
unempset.append(0)
if tyott:
unempset=[0,4,13]
if laaja:
unempset=[0,4,11,13]
if kaikki:
unempset=[0,2,3,4,5,6,7,8,9,11,12,13,14]
unempset=set(unempset)
if popempstate is None:
popempstate=self.popempstate
keskikesto=np.zeros((5,5)) # 20-29, 30-39, 40-49, 50-59, 60-69, vastaa TYJin tilastoa
n=np.zeros(5)
for k in range(self.n_pop):
prev_state=popempstate[0,k]
prev_trans=0
for t in range(1,self.n_time):
age=self.min_age+t*self.timestep
if age<=max_age:
if popempstate[t,k]!=prev_state:
if prev_state in unempset and popempstate[t,k] not in unempset:
prev_state=popempstate[t,k]
duration=(t-prev_trans)*self.timestep
prev_trans=t
if age<29:
l=0
elif age<39:
l=1
elif age<49:
l=2
elif age<59:
l=3
else:
l=4
n[l]+=1
if duration<=0.51:
keskikesto[l,0]+=1
elif duration<=1.01:
keskikesto[l,1]+=1
elif duration<=1.51:
keskikesto[l,2]+=1
elif duration<=2.01:
keskikesto[l,3]+=1
else:
keskikesto[l,4]+=1
elif prev_state not in unempset and popempstate[t,k] in unempset:
prev_trans=t
prev_state=popempstate[t,k]
else: # some other state
prev_state=popempstate[t,k]
prev_trans=t
for k in range(5):
keskikesto[k,:] /= n[k]
if return_q:
return self.empdur_to_dict(keskikesto)
else:
return keskikesto
def comp_virrat(self,popempstate=None,putki=True,tmtuki=True,laaja=False,outsider=False,ansiosid=True,tyott=False,kaikki=False,max_age=100):
tyoll_virta=np.zeros((self.n_time,1))
tyot_virta=np.zeros((self.n_time,1))
unempset=[]
empset=[]
if tmtuki:
unempset.append(13)
if outsider:
unempset.append(11)
if putki:
unempset.append(4)
if ansiosid:
unempset.append(0)
if tyott:
unempset=[0,4,13]
if laaja:
unempset=[0,4,11,13]
if kaikki:
unempset=[0,2,3,4,5,6,7,8,9,11,12,13,14]
empset=set([1,10])
unempset=set(unempset)
if popempstate is None:
popempstate=self.popempstate
for k in range(self.n_pop):
prev_state=popempstate[0,k]
prev_trans=0
for t in range(1,self.n_time):
age=self.min_age+t*self.timestep
if age<=max_age:
if popempstate[t,k]!=prev_state:
if prev_state in unempset and popempstate[t,k] in empset:
tyoll_virta[t]+=1
prev_state=popempstate[t,k]
elif prev_state in empset and popempstate[t,k] in unempset:
tyot_virta[t]+=1
prev_state=popempstate[t,k]
else: # some other state
prev_state=popempstate[t,k]
return tyoll_virta,tyot_virta
def comp_tyollistymisdistribs(self,popempstate=None,popunemprightleft=None,putki=True,tmtuki=True,laaja=False,outsider=False,ansiosid=True,tyott=False,max_age=100):
tyoll_distrib=[]
tyoll_distrib_bu=[]
unempset=[]
if tmtuki:
unempset.append(13)
if outsider:
unempset.append(11)
if putki:
unempset.append(4)
if ansiosid:
unempset.append(0)
if tyott:
unempset=[0,4,13]
if laaja:
unempset=[0,4,11,13]
empset=set([1,10])
unempset=set(unempset)
if popempstate is None or popunemprightleft is None:
popempstate=self.popempstate
popunemprightleft=self.popunemprightleft
for k in range(self.n_pop):
prev_state=popempstate[0,k]
prev_trans=0
for t in range(1,self.n_time):
age=self.min_age+t*self.timestep
if age<=max_age:
if popempstate[t,k]!=prev_state:
if prev_state in unempset and popempstate[t,k] in empset:
tyoll_distrib.append((t-prev_trans)*self.timestep)
tyoll_distrib_bu.append(popunemprightleft[t,k])
prev_state=popempstate[t,k]
prev_trans=t
else: # some other state
prev_state=popempstate[t,k]
prev_trans=t
return tyoll_distrib,tyoll_distrib_bu
def comp_empdistribs(self,popempstate=None,popunemprightleft=None,putki=True,tmtuki=True,laaja=False,outsider=False,ansiosid=True,tyott=False,max_age=100):
unemp_distrib=[]
unemp_distrib_bu=[]
emp_distrib=[]
unempset=[]
if tmtuki:
unempset.append(13)
if outsider:
unempset.append(11)
if putki:
unempset.append(4)
if ansiosid:
unempset.append(0)
if tyott:
unempset=[0,4,13]
if laaja:
unempset=[0,4,11,13]
if popempstate is None or popunemprightleft is None:
popempstate=self.popempstate
popunemprightleft=self.popunemprightleft
empset=set([1,10])
unempset=set(unempset)
for k in range(self.n_pop):
prev_state=popempstate[0,k]
prev_trans=0
for t in range(1,self.n_time):
age=self.min_age+t*self.timestep
if age<=max_age:
if self.popempstate[t,k]!=prev_state:
if prev_state in unempset and popempstate[t,k] not in unempset:
unemp_distrib.append((t-prev_trans)*self.timestep)
unemp_distrib_bu.append(popunemprightleft[t,k])
prev_state=popempstate[t,k]
prev_trans=t
elif prev_state in empset and popempstate[t,k] not in unempset:
emp_distrib.append((t-prev_trans)*self.timestep)
prev_state=popempstate[t,k]
prev_trans=t
else: # some other state
prev_state=popempstate[t,k]
prev_trans=t
return unemp_distrib,emp_distrib,unemp_distrib_bu
def empdist_stat(self):
ratio=np.array([1,0.287024901703801,0.115508955875928,0.0681083442551332,0.0339886413280909,0.0339886413280909,0.0114460463084316,0.0114460463084316,0.0114460463084316,0.00419397116644823,0.00419397116644823,0.00419397116644823,0.00419397116644823,0.00419397116644823,0.00419397116644823,0.00419397116644823,0.00419397116644823,0.00166011358671909,0.00166011358671909,0.00166011358671909,0.00166011358671909,0.00166011358671909,0.00166011358671909,0.00166011358671909,0.00166011358671909,0.00104849279161206,0.00104849279161206,0.00104849279161206,0.00104849279161206,0.00104849279161206,0.00104849279161206,0.00104849279161206,0.00104849279161206])
return ratio
def comp_gempratios(self,unempratio=True,gender='men'):
if gender=='men': # men
gempstate=np.sum(self.gempstate[:,:,0:3],axis=2)
alive=np.zeros((self.galive.shape[0],1))
alive[:,0]=np.sum(self.galive[:,0:3],1)
mother_in_workforce=0
else: # women
gempstate=np.sum(self.gempstate[:,:,3:6],axis=2)
alive=np.zeros((self.galive.shape[0],1))
alive[:,0]=np.sum(self.galive[:,3:6],1)
mother_in_workforce=self.infostats_mother_in_workforce
tyollisyysaste,osatyoaste,tyottomyysaste,ka_tyottomyysaste=self.comp_empratios(gempstate,alive,unempratio=unempratio,mother_in_workforce=mother_in_workforce)
return tyollisyysaste,osatyoaste,tyottomyysaste,ka_tyottomyysaste
def comp_empratios(self,emp,alive,unempratio=True,mother_in_workforce=0):
employed=emp[:,1]
retired=emp[:,2]
unemployed=emp[:,0]
if self.version in set([1,2,3,4]):
disabled=emp[:,3]
piped=emp[:,4]
mother=emp[:,5]
dad=emp[:,6]
kotihoidontuki=emp[:,7]
vetyo=emp[:,9]
veosatyo=emp[:,8]
osatyo=emp[:,10]
outsider=emp[:,11]
student=emp[:,12]
tyomarkkinatuki=emp[:,13]
tyollisyysaste=100*(employed+osatyo+veosatyo+vetyo+dad+mother_in_workforce)/alive[:,0]
osatyoaste=100*(osatyo+veosatyo)/(employed+osatyo+veosatyo+vetyo)
if unempratio:
tyottomyysaste=100*(unemployed+piped+tyomarkkinatuki)/(tyomarkkinatuki+unemployed+employed+piped+osatyo+veosatyo+vetyo)
ka_tyottomyysaste=100*np.sum(unemployed+tyomarkkinatuki+piped)/np.sum(tyomarkkinatuki+unemployed+employed+piped+osatyo+veosatyo+vetyo)
else:
tyottomyysaste=100*(unemployed+piped+tyomarkkinatuki)/alive[:,0]
ka_tyottomyysaste=100*np.sum(unemployed+tyomarkkinatuki+piped)/np.sum(alive[:,0])
elif self.version in set([0,101]):
if False:
osatyo=emp[:,3]
else:
osatyo=0
tyollisyysaste=100*(employed+osatyo)/alive[:,0]
#osatyoaste=np.zeros(employed.shape)
osatyoaste=100*(osatyo)/(employed+osatyo)
if unempratio:
tyottomyysaste=100*(unemployed)/(unemployed+employed+osatyo)
ka_tyottomyysaste=100*np.sum(unemployed)/np.sum(unemployed+employed+osatyo)
else:
tyottomyysaste=100*(unemployed)/alive[:,0]
ka_tyottomyysaste=100*np.sum(unemployed)/np.sum(alive[:,0])
return tyollisyysaste,osatyoaste,tyottomyysaste,ka_tyottomyysaste
def plot_ratiostats(self,t):
'''
Tee kuvia tuloksista
'''
x=np.linspace(self.min_age,self.max_age,self.n_time)
fig,ax=plt.subplots()
ax.set_xlabel('palkat')
ax.set_ylabel('freq')
ax.hist(self.infostats_pop_wage[t,:])
plt.show()
fig,ax=plt.subplots()
ax.set_xlabel('aika')
ax.set_ylabel('palkat')
meansal=np.mean(self.infostats_pop_wage,axis=1)
stdsal=np.std(self.infostats_pop_wage,axis=1)
ax.plot(x,meansal)
ax.plot(x,meansal+stdsal)
ax.plot(x,meansal-stdsal)
plt.show()
def plot_empdistribs(self,emp_distrib):
fig,ax=plt.subplots()
ax.set_xlabel('työsuhteen pituus [v]')
ax.set_ylabel('freq')
ax.set_yscale('log')
max_time=50
nn_time = int(np.round((max_time)*self.inv_timestep))+1
x=np.linspace(0,max_time,nn_time)
scaled,x2=np.histogram(emp_distrib,x)
scaled=scaled/np.sum(emp_distrib)
#ax.hist(emp_distrib)
ax.bar(x2[1:-1],scaled[1:],align='center')
plt.show()
def plot_compare_empdistribs(self,emp_distrib,emp_distrib2,label2='vaihtoehto',label1=''):
fig,ax=plt.subplots()
ax.set_xlabel('työsuhteen pituus [v]')
ax.set_ylabel(self.labels['probability'])
ax.set_yscale('log')
max_time=50
nn_time = int(np.round((max_time)*self.inv_timestep))+1
x=np.linspace(0,max_time,nn_time)
scaled,x2=np.histogram(emp_distrib,x)
scaled=scaled/np.sum(emp_distrib)
x=np.linspace(0,max_time,nn_time)
scaled3,x3=np.histogram(emp_distrib2,x)
scaled3=scaled3/np.sum(emp_distrib2)
ax.plot(x3[:-1],scaled3,label=label1)
ax.plot(x2[:-1],scaled,label=label2)
ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.show()
def plot_vlines_unemp(self,point=0):
axvcolor='gray'
lstyle='--'
plt.axvline(x=300/(12*21.5),ls=lstyle,color=axvcolor)
plt.text(310/(12*21.5),point,'300',rotation=90)
plt.axvline(x=400/(12*21.5),ls=lstyle,color=axvcolor)
plt.text(410/(12*21.5),point,'400',rotation=90)
plt.axvline(x=500/(12*21.5),ls=lstyle,color=axvcolor)
plt.text(510/(12*21.5),point,'500',rotation=90)
def plot_tyolldistribs(self,emp_distrib,tyoll_distrib,tyollistyneet=True,max=10,figname=None):
max_time=55
nn_time = int(np.round((max_time)*self.inv_timestep))+1
x=np.linspace(0,max_time,nn_time)
scaled0,x0=np.histogram(emp_distrib,x)
if not tyollistyneet:
scaled=scaled0
x2=x0
else:
scaled,x2=np.histogram(tyoll_distrib,x)
jaljella=np.cumsum(scaled0[::-1])[::-1] # jäljellä olevien kumulatiivinen summa
scaled=scaled/jaljella
fig,ax=plt.subplots()
ax.set_xlabel('työttömyysjakson pituus [v]')
if tyollistyneet:
ax.set_ylabel('työllistyneiden osuus')
point=0.5
else:
ax.set_ylabel('pois siirtyneiden osuus')
point=0.9
self.plot_vlines_unemp(point)
ax.plot(x2[1:-1],scaled[1:])
#ax.bar(x2[1:-1],scaled[1:],align='center',width=self.timestep)
plt.xlim(0,max)
if figname is not None:
plt.savefig(figname+'tyollistyneetdistrib.eps', format='eps')
plt.show()
def plot_tyolldistribs_both(self,emp_distrib,tyoll_distrib,max=10,figname=None):
max_time=50
nn_time = int(np.round((max_time)*self.inv_timestep))+1
x=np.linspace(0,max_time,nn_time)
scaled0,x0=np.histogram(emp_distrib,x)
scaled=scaled0
scaled_tyoll,x2=np.histogram(tyoll_distrib,x)
jaljella=np.cumsum(scaled0[::-1])[::-1] # jäljellä olevien summa
scaled=scaled/jaljella
jaljella_tyoll=np.cumsum(scaled0[::-1])[::-1] # jäljellä olevien summa
scaled_tyoll=scaled_tyoll/jaljella_tyoll
fig,ax=plt.subplots()
ax.set_xlabel('työttömyysjakson pituus [v]')
point=0.6
self.plot_vlines_unemp(point)
ax.plot(x2[1:-1],scaled[1:],label='pois siirtyneiden osuus')
ax.plot(x2[1:-1],scaled_tyoll[1:],label='työllistyneiden osuus')
#ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
ax.legend()
ax.set_ylabel('pois siirtyneiden osuus')
plt.xlim(0,max)
plt.ylim(0,0.8)
if figname is not None:
plt.savefig(figname+'tyolldistribs.eps', format='eps')
plt.show()
def plot_tyolldistribs_both_bu(self,emp_distrib,tyoll_distrib,max=2):
max_time=4
nn_time = int(np.round((max_time)*self.inv_timestep))+1
x=np.linspace(-max_time,0,nn_time)
scaled0,x0=np.histogram(emp_distrib,x)
scaled=scaled0
scaled_tyoll,x2=np.histogram(tyoll_distrib,x)
jaljella=np.cumsum(scaled0[::-1])[::-1] # jäljellä olevien summa
#jaljella=np.cumsum(scaled0)
scaled=scaled/jaljella
jaljella_tyoll=np.cumsum(scaled0[::-1])[::-1] # jäljellä olevien summa
#jaljella_tyoll=np.cumsum(scaled0)
scaled_tyoll=scaled_tyoll/jaljella_tyoll
fig,ax=plt.subplots()
ax.set_xlabel('aika ennen ansiopäivärahaoikeuden loppua [v]')
point=0.6
#self.plot_vlines_unemp(point)
ax.plot(x2[1:-1],scaled[1:],label='pois siirtyneiden osuus')
ax.plot(x2[1:-1],scaled_tyoll[1:],label='työllistyneiden osuus')
ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
ax.set_ylabel('pois siirtyneiden osuus')
plt.xlim(-max,0)
#plt.ylim(0,0.8)
plt.show()
def plot_compare_tyolldistribs(self,emp_distrib1,tyoll_distrib1,emp_distrib2,
tyoll_distrib2,tyollistyneet=True,max=4,label1='perus',label2='vaihtoehto',
figname=None):
max_time=50
nn_time = int( | np.round((max_time)*self.inv_timestep) | numpy.round |
import numpy as np
from math import cos, sin, pi
import math
import cv2
from scipy.spatial import Delaunay
def softmax(x):
x -= np.max(x,axis=1, keepdims=True)
a = np.exp(x)
b = np.sum(np.exp(x), axis=1, keepdims=True)
return a/b
def draw_axis(img, yaw, pitch, roll, tdx=None, tdy=None, size = 100):
# Referenced from HopeNet https://github.com/natanielruiz/deep-head-pose
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 * (cos(yaw) * cos(roll)) + tdx
y1 = size * (cos(pitch) * sin(roll) + cos(roll) * sin(pitch) * sin(yaw)) + tdy
# Y-Axis | drawn in green
# v
x2 = size * (-cos(yaw) * sin(roll)) + tdx
y2 = size * (cos(pitch) * cos(roll) - sin(pitch) * sin(yaw) * sin(roll)) + tdy
# Z-Axis (out of the screen) drawn in blue
x3 = size * (sin(yaw)) + tdx
y3 = size * (-cos(yaw) * sin(pitch)) + tdy
cv2.line(img, (int(tdx), int(tdy)), (int(x1),int(y1)),(0,0,255),2)
cv2.line(img, (int(tdx), int(tdy)), (int(x2),int(y2)),(0,255,0),2)
cv2.line(img, (int(tdx), int(tdy)), (int(x3),int(y3)),(255,0,0),2)
return img
def projectPoints(X, K, R, t, Kd):
""" Projects points X (3xN) using camera intrinsics K (3x3),
extrinsics (R,t) and distortion parameters Kd=[k1,k2,p1,p2,k3].
Roughly, x = K*(R*X + t) + distortion
See http://docs.opencv.org/2.4/doc/tutorials/calib3d/camera_calibration/camera_calibration.html
or cv2.projectPoints
"""
x = np.asarray(R * X + t)
x[0:2, :] = x[0:2, :] / x[2, :]
r = x[0, :] * x[0, :] + x[1, :] * x[1, :]
x[0, :] = x[0, :] * (1 + Kd[0] * r + Kd[1] * r * r + Kd[4] * r * r * r) + 2 * Kd[2] * x[0, :] * x[1, :] + Kd[3] * (
r + 2 * x[0, :] * x[0, :])
x[1, :] = x[1, :] * (1 + Kd[0] * r + Kd[1] * r * r + Kd[4] * r * r * r) + 2 * Kd[3] * x[0, :] * x[1, :] + Kd[2] * (
r + 2 * x[1, :] * x[1, :])
x[0, :] = K[0, 0] * x[0, :] + K[0, 1] * x[1, :] + K[0, 2]
x[1, :] = K[1, 0] * x[0, :] + K[1, 1] * x[1, :] + K[1, 2]
return x
def align(model, data):
"""Align two trajectories using the method of Horn (closed-form).
https://github.com/raulmur/evaluate_ate_scale
Input:
model -- first trajectory (3xn)
data -- second trajectory (3xn)
Output:
rot -- rotation matrix (3x3)
trans -- translation vector (3x1)
trans_error -- translational error per point (1xn)
"""
np.set_printoptions(precision=3, suppress=True)
model_zerocentered = model - model.mean(1)
data_zerocentered = data - data.mean(1)
W = np.zeros((3, 3))
for column in range(model.shape[1]):
W += np.outer(model_zerocentered[:, column], data_zerocentered[:, column])
U, d, Vh = np.linalg.linalg.svd(W.transpose())
S = np.matrix(np.identity(3))
if (np.linalg.det(U) * np.linalg.det(Vh) < 0):
S[2, 2] = -1
rot = U * S * Vh
rotmodel = rot * model_zerocentered
dots = 0.0
norms = 0.0
for column in range(data_zerocentered.shape[1]):
dots += np.dot(data_zerocentered[:, column].transpose(), rotmodel[:, column])
normi = np.linalg.norm(model_zerocentered[:, column])
norms += normi * normi
s = float(dots / norms)
trans = data.mean(1) - s * rot * model.mean(1)
model_aligned = s * rot * model + trans
alignment_error = model_aligned - data
trans_error = np.sqrt(np.sum(np.multiply(alignment_error, alignment_error), 0)).A[0]
return rot, trans, trans_error, s
def rotationMatrixToEulerAngles2(R):
y1 = -math.asin(R[2,0])
y2 = math.pi - y1
if y1>math.pi:
y1 = y1 - 2*math.pi
if y2>math.pi:
y2 = y2 - 2*math.pi
x1 = math.atan2(R[2,1]/math.cos(y1), R[2,2]/math.cos(y1))
x2 = math.atan2(R[2,1]/math.cos(y2), R[2,2]/math.cos(y2))
z1 = math.atan2(R[1,0]/math.cos(y1), R[0,0]/math.cos(y1))
z2 = math.atan2(R[1, 0] / math.cos(y2), R[0, 0] / math.cos(y2))
return [x1, y1, z1], [x2, y2, z2]
def reference_head(scale=0.01,pyr=(10.,0.0,0.0)):
kps = np.asarray([[-7.308957, 0.913869, 0.000000], [-6.775290, -0.730814, -0.012799],
[-5.665918, -3.286078, 1.022951], [-5.011779, -4.876396, 1.047961],
[-4.056931, -5.947019, 1.636229], [-1.833492, -7.056977, 4.061275],
[0.000000, -7.415691, 4.070434], [1.833492, -7.056977, 4.061275],
[4.056931, -5.947019, 1.636229], [5.011779, -4.876396, 1.047961],
[5.665918, -3.286078, 1.022951],
[6.775290, -0.730814, -0.012799], [7.308957, 0.913869, 0.000000],
[5.311432, 5.485328, 3.987654], [4.461908, 6.189018, 5.594410],
[3.550622, 6.185143, 5.712299], [2.542231, 5.862829, 4.687939],
[1.789930, 5.393625, 4.413414], [2.693583, 5.018237, 5.072837],
[3.530191, 4.981603, 4.937805], [4.490323, 5.186498, 4.694397],
[-5.311432, 5.485328, 3.987654], [-4.461908, 6.189018, 5.594410],
[-3.550622, 6.185143, 5.712299], [-2.542231, 5.862829, 4.687939],
[-1.789930, 5.393625, 4.413414], [-2.693583, 5.018237, 5.072837],
[-3.530191, 4.981603, 4.937805], [-4.490323, 5.186498, 4.694397],
[1.330353, 7.122144, 6.903745], [2.533424, 7.878085, 7.451034],
[4.861131, 7.878672, 6.601275], [6.137002, 7.271266, 5.200823],
[6.825897, 6.760612, 4.402142], [-1.330353, 7.122144, 6.903745],
[-2.533424, 7.878085, 7.451034], [-4.861131, 7.878672, 6.601275],
[-6.137002, 7.271266, 5.200823], [-6.825897, 6.760612, 4.402142],
[-2.774015, -2.080775, 5.048531], [-0.509714, -1.571179, 6.566167],
[0.000000, -1.646444, 6.704956], [0.509714, -1.571179, 6.566167],
[2.774015, -2.080775, 5.048531], [0.589441, -2.958597, 6.109526],
[0.000000, -3.116408, 6.097667], [-0.589441, -2.958597, 6.109526],
[-0.981972, 4.554081, 6.301271], [-0.973987, 1.916389, 7.654050],
[-2.005628, 1.409845, 6.165652], [-1.930245, 0.424351, 5.914376],
[-0.746313, 0.348381, 6.263227], [0.000000, 0.000000, 6.763430],
[0.746313, 0.348381, 6.263227], [1.930245, 0.424351, 5.914376],
[2.005628, 1.409845, 6.165652], [0.973987, 1.916389, 7.654050],
[0.981972, 4.554081, 6.301271]]).T
R = rotate_zyx( | np.deg2rad(pyr) | numpy.deg2rad |
import torch
import torch.nn as nn
import numpy as np
import os
from torch.utils.data import DataLoader
from dataset.UCFRep_loader import TestData
from tqdm import tqdm, trange
from models.TransRAC import TransferModel
from tools.my_tools import paint_smi_matrixs,density_map
device_ids = [0]
device = torch.device("cuda:" + str(device_ids[0]) if torch.cuda.is_available() else "cpu")
torch.manual_seed(1)
def test_loop(n_epochs, model,test_set,batch_size=1, lastckpt=None, paint=False, device_ids=[0]):
device = torch.device("cuda:" + str(device_ids[0]) if torch.cuda.is_available() else "cpu")
currEpoch = 0
testloader = DataLoader(test_set, batch_size=batch_size, pin_memory=True, shuffle=True, num_workers=20)
model = nn.DataParallel(model.to(device), device_ids=device_ids)
if lastckpt != None:
print("loading checkpoint")
checkpoint = torch.load(lastckpt)
currEpoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'], strict=False)
del checkpoint
for epoch in tqdm(range(currEpoch, n_epochs + currEpoch)):
testOBO = []
testMAE = []
predCount=[]
Count=[]
ACC=[]
with torch.no_grad():
batch_idx = 0
pbar = tqdm(testloader, total=len(testloader))
for input, target in pbar:
model.eval()
acc = 0
input = input.to(device)
count = target.to(device)
output, sim_matrix = model(input, epoch)
predict_count = torch.sum(output, dim=1).round()
mae = torch.sum(torch.div(torch.abs(predict_count - count), count + 1e-1)) / \
predict_count.flatten().shape[0] # mae
gaps = torch.sub(predict_count, count).reshape(-1).cpu().detach().numpy().reshape(-1).tolist()
for item in gaps:
if abs(item) <= 1:
acc += 1
OBO = acc / predict_count.flatten().shape[0]
testOBO.append(OBO)
MAE = mae.item()
testMAE.append(MAE)
predCount.append(predict_count.item())
Count.append(count.item())
print('predict count :{0}, groundtruth :{1}'.format(predict_count.item(), count.item()))
#if predict_count.item() == count.item() and MAE < 0.2:
# density_map(output, count.item(), batch_idx)
# if paint:
# paint_smi_matrixs(sim_matrix,batch_idx)
batch_idx += 1
print("MAE:{0},OBO:{1}".format( | np.mean(testMAE) | numpy.mean |
import numpy as np
INSTRU = 0 # so that data[INSTRU] = instrumental
def initialValues(data, model, options):
# Initializes the parameter values for the MCMC procedure
# Draws from (at times) truncated priors.
currentParams = {}
if options['useModes']:
# Initial Value of alpha: (uniform, so take mean):
currentParams['alpha'] = np.mean(options['priors']['alpha'][:])
# Initial Value for mu: mode of the normal prior.
currentParams['mu'] = options['priors']['mu'][0]
# Initial Value for sigma2: mode of inverse gamma prior:
currentParams['sigma2'] = options['priors']['sigma2'][1] / (options['priors']['sigma2'][0] + 1)
# Initial Value for phi: mode of the log-normal distribution:
currentParams['phi'] = np.exp(options['priors']['phi'][0] - options['priors']['phi'][1])
# Initial Value for tau2_I: : mode of inverse gamma prior:
currentParams['tau2_I'] = options['priors']['tau2_I'][1] / (options['priors']['tau2_I'][0] + 1)
# Initial Value for tau2_P: : mode of inverse gamma prior:
currentParams['tau2_P'] = options['priors']['tau2_P'][:, 1] / (options['priors']['tau2_P'][:, 0] + 1)
# Initial value for Beta_1: mode of the normal prior:
currentParams['Beta_1'] = options['priors']['Beta_1'][:, 0]
# Initial value for Beta_0: mode of the normal prior:
currentParams['Beta_0'] = options['priors']['Beta_0'][:, 0]
else:
# Initial Value of alpha: Draw from the uniform prior:
# currentParams.alpha=rand(1)*diff(options.priors.alpha)+options.priors.alpha(1);
# TRUNCATE A Bit to set initial value near 0.5:
currentParams['alpha'] = np.random.rand() * 0.5 + 0.25
# Initial Value for mu: draw from the normal prior.
currentParams['mu'] = options['priors']['mu'][0] + np.sqrt(options['priors']['mu'][1]) * np.random.normal()
# Initial Value for sigma2: draw from inverse gamma prior is likely a bad ideas,
# due to the very large possible values. So truncate to below some value:
while True:
t = 1 / np.random.gamma(options['priors']['sigma2'][0], 1 / options['priors']['sigma2'][1]) # right?
if t < 5:
currentParams['sigma2'] = t
break
# Initial Value for phi: draw from the log-normal distribution, truncated to less than a cutoff,
# determined by the prior parameters:
cutt = np.exp(options['priors']['phi'][0] + 2 * np.sqrt(options['priors']['phi'][1]))
while True:
t = np.random.lognormal(options['priors']['phi'][0], np.sqrt(options['priors']['phi'][1]))
if t < cutt:
currentParams['phi'] = t
break
# Initial Value for tau2_I: : draw from inverse gamma prior truncated to less than some cut off value:
while True:
t = 1 / np.random.gamma(options['priors']['tau2_I'][0], 1 / options['priors']['tau2_I'][1])
if t < 5:
currentParams['tau2_I'] = t
break
if len(data) > 1:
# Initial Value for tau2_P: : draw from inverse gamma prior truncated to less than some cut off value:
pars = options['priors']['tau2_P'][:]
vals = np.zeros((np.size(pars, 0), 1))
for i in range(np.size(pars, 0)):
while True:
t = 1 / np.random.gamma(pars[i, 0], 1 / pars[i, 1])
if t < 10:
vals[i] = t
break
currentParams['tau2_P'] = vals
# Initial value for Beta_1: mode of the normal prior:
currentParams['Beta_1'] = options['priors']['Beta_1'][0] + np.random.rand(
| np.size(options['priors']['Beta_1'], 1) | numpy.size |
"""
Scan a large frequency range at a given frequency resolution. At each LO frequency, scan most of the positive baseband
frequencies and save one SweepArray.
"""
from __future__ import division
import time
import numpy as np
from kid_readout.roach import analog, hardware_tools, tools
from kid_readout.measurement import acquire, basic, core
from kid_readout.equipment import hardware
acquire.show_settings()
acquire.show_git_status()
logger = acquire.get_script_logger(__file__)
# Parameters
suffix = 'scan'
attenuation = 0
df_baseband_target = 25e3
f_start = 1500e6
f_stop = 3500e6
overlap_fraction = 0.5
f_baseband_minimum = 10e6 # Keep the tones above the LO by at least this frequency
f_baseband_maximum = 180e6 # Keep the tones below this frequency
length_seconds = 0.01
filterbank_bin_separation = 4 # The minimum number of PFB bins that separate tones
f_lo_resolution = 2.5e3 # The minimum
num_tones_maximum = 128 # Imposed by the data streaming rate
#fft_gain_maximum = 4
# Hardware
conditioner = analog.HeterodyneMarkII()
hw = hardware.Hardware(conditioner)
ri = hardware_tools.r2h14_with_mk2(initialize=True, use_config=False)
ri.adc_valon.set_ref_select(0)
assert np.all(ri.adc_valon.get_phase_locks())
# Calculate sweep parameters, LO and baseband sweep frequencies
ri_state = ri.state
# The tone sample exponent (and thus the number of tone samples) are set so that the actual frequency spacing
# is less than the target frequency spacing.
tone_sample_exponent = int(np.ceil(np.log2(ri_state.adc_sample_rate / df_baseband_target)))
df_baseband = ri_state.adc_sample_rate / 2 ** tone_sample_exponent
logger.info("Baseband resolution is {:.0f} Hz using 2^{:d} samples".format(df_baseband, tone_sample_exponent))
df_filterbank = ri_state.adc_sample_rate / ri_state.num_filterbank_channels
df_tone_minimum = df_filterbank * filterbank_bin_separation # The minimum distance between tones
df_tone = max([df_tone_minimum])
logger.info("Separating tones by {:d} filterbank bins, or {:.3f} MHz".format(
filterbank_bin_separation, 1e-6 * df_tone))
num_waveforms = filterbank_bin_separation * 2 ** tone_sample_exponent // ri_state.num_filterbank_channels
num_tones = min([num_tones_maximum,
2 ** int(np.log2((f_baseband_maximum - f_baseband_minimum) / df_tone))])
df_sweep = df_tone * num_tones
logger.info("Each sweep consists of {:d} waveforms of {:d} tones and spans {:.1f} MHz".format(
num_waveforms, num_tones, 1e-6 * df_sweep))
df_lo = (1 - overlap_fraction) * df_sweep
logger.info("With {:.2f} fractional overlap, LO frequencies are separated by {:.1f} MHz".format(
overlap_fraction, 1e-6 * df_lo))
num_sweeps = int( | np.ceil((f_stop - f_start) / df_lo) | numpy.ceil |
def dataCleaning(marriageNum='Full', classNum=2, dropColumns=True):
'''
This is the data cleaning function for the CE264 final project: Marriage Analysis
Return a pandas data frame and a numpy array: data (X) and observation (y)
The name of each column refers to the JGSS data codebook
For some combined categories in a particular data feature, please refer to the source code
Parameters:
marriageNum: integer or 'Full'(as default); the number of sampled 'Marriage' class,
should be smaller than its actual number
classNum: 2(as default), 3 or 'Full'; the class number of the observation;
if 2, class 1 for 'Currently Marriage' and 2 for other
if 3, class 1 for 'Currently Marriage', 2 for 'Divorced', and 3 for other
if 'Full', check the code book for the meaning of each class
dropColumns: whether drop the columns that may have correlation with the marriage status (default is True)
'''
# parameter check
if classNum not in [2, 3, 'Full']:
raise ValueError('Invalid class number: should be 2, 3, or "Full".')
# import libraries and raw data
import numpy as np
import pandas as pd
rawData = pd.read_stata('34623-0001-Data.dta')
# data selected primarily by genetic algorithm
selectedCol = ['SIZE', 'SEXA', 'TP5UNEMP', 'AGESTPWK', 'SZSJBHWK', 'TPJOBP', 'TPJBDP', 'SZCMTHR', 'XXJOB',
'XJOBDWK', 'SZTTLSTA', 'ST5JOB', 'SSJB1WK', 'SSTPUNEM', 'SSSJBHWK', 'SSTPJOB','SSTPJBDP',
'SSTPJBSE', 'SSXJBSCH', 'SSSZWKYR', 'SSSZSTFA', 'SPAGEX', 'SPLVTG', 'PPLVTG', 'MMLVTG', 'PPAGE',
'MMAGE', 'MMJOB', 'CCNUMTTL', 'CC01SEX', 'CC01AGE', 'CC02LVTG', 'CC02AGE', 'CC02MG', 'CC03MG',
'CC03JOB', 'CC04LVTG', 'CC04MG', 'CC05SEX', 'CC05JOB', 'CC06SEX', 'CC06AGE', 'CC07SEX',
'CC07LVTG', 'CC07AGE', 'CC07JOB', 'CC08MG', 'CC08JOB', 'SZFFOTHR', 'FFH01REL', 'FFH03SEX',
'FFH04REL', 'FFH04SEX', 'FFH05REL', 'FFH05SEX', 'FFH07REL', 'FFH07SEX', 'FFH07AGE', 'SZFFONLY',
'SZFFTTL', 'FFHEAD', 'SZFFOUT', 'FFO01REL', 'FFO01WHY', 'FFO02REL', 'FFO02WHY', 'FFO03REL',
'FFO03WHY', 'FFO05REL', 'FFO05WHY', 'FFO06REL', 'FFO06WHY', 'INCSELF', 'INCSP', 'INCPEN',
'INCUEB', 'INCIRR', 'INCRENT', 'INCMAIN', 'SZINCOMA', 'XNUMSISE', 'XNUMBROY', 'XSSNBROY',
'XSSNSISY', 'PREF15', 'TP5LOC15', 'PPJBXX15', 'PPJBSZ15', 'MMJBTP15', 'XXLSTSCH','SSLSTSCH',
'PPLSTSCH', 'DOLSTSCH', 'XGRADE', 'XSPSCH', 'MARC']
selectedData = rawData[selectedCol]
# filter data with more than 1500 'NA' values
NAfilter = []
for i in selectedCol:
if len(selectedData[selectedData[i] == 'Not applicable']) < 1500:
NAfilter += [i]
selectedData = selectedData[NAfilter]
# sample the marriage class
if marriageNum != 'Full':
marriageClass = selectedData[selectedData['MARC'] == 'Currently married']
dropNum = len(marriageClass) - marriageNum
if not dropNum > 0:
raise ValueError('The number of sampled "Marriage" class should be smaller than its actual number. Try another value.')
drop_id = np.random.choice(marriageClass.index, dropNum, replace=False)
selectedData = selectedData.drop(drop_id)
# data cleaning...
selectedData['SIZE'].replace('Largest cities', 1, inplace=True)
selectedData['SIZE'].replace('Cities with population of 200000 or more', 2, inplace=True)
selectedData['SIZE'].replace('Cities with population of less than 200000', 3, inplace=True)
selectedData['SIZE'].replace('Town/village', 4, inplace=True)
selectedData['SEXA'].replace('Male', 1, inplace=True)
selectedData['SEXA'].replace('Female', 2, inplace=True)
selectedData['SSJB1WK'].replace('He/she worked last week.', 1, inplace=True)
selectedData['SSJB1WK'].replace('He/she was going to work last week, but did not work.', 2, inplace=True)
selectedData['SSJB1WK'].replace('He/she did not work.', 3, inplace=True)
selectedData['SPLVTG'].replace('Living together', 1, inplace=True)
selectedData['SPLVTG'].replace('Not living together (because of work circumstances)', 2, inplace=True)
selectedData['SPLVTG'].replace('Not living together (for other reasons)', 3, inplace=True)
selectedData['PPLVTG'].replace('Living together', 1, inplace=True)
selectedData['PPLVTG'].replace('Not living together', 2, inplace=True)
selectedData['PPLVTG'].replace('Deceased', 3, inplace=True)
selectedData['MMLVTG'].replace('Living together', 1, inplace=True)
selectedData['MMLVTG'].replace('Not living together', 2, inplace=True)
selectedData['MMLVTG'].replace('Deceased', 3, inplace=True)
selectedData['CC01SEX'].replace('Male', 1, inplace=True)
selectedData['CC01SEX'].replace('Female', 2, inplace=True)
for i in np.unique(selectedData['FFHEAD']):
if i not in ['Respondent himself/herself', 'Husband', 'Wife']:
selectedData['FFHEAD'].replace(i, 4, inplace=True)
selectedData['FFHEAD'].replace('Respondent himself/herself', 1, inplace=True)
selectedData['FFHEAD'].replace('Husband', 2, inplace=True)
selectedData['FFHEAD'].replace('Wife', 3, inplace=True)
selectedData['INCSELF'].replace('Chosen', 0, inplace=True)
selectedData['INCSELF'].replace('Not chosen', 1, inplace=True)
selectedData['INCSP'].replace('Chosen', 1, inplace=True)
selectedData['INCSP'].replace('Not chosen', 1, inplace=True)
selectedData['INCPEN'].replace('Chosen', 0, inplace=True)
selectedData['INCPEN'].replace('Not chosen', 1, inplace=True)
selectedData['INCUEB'].replace('Chosen', 0, inplace=True)
selectedData['INCUEB'].replace('Not chosen', 1, inplace=True)
selectedData['INCIRR'].replace('Chosen', 0, inplace=True)
selectedData['INCIRR'].replace('Not chosen', 1, inplace=True)
selectedData['INCRENT'].replace('Chosen', 0, inplace=True)
selectedData['INCRENT'].replace('Not chosen', 1, inplace=True)
selectedData.drop('INCMAIN', axis=1, inplace=True)
for i in np.unique(selectedData['SZINCOMA']):
if i == 'None':
selectedData['SZINCOMA'].replace(i, 1, inplace=True)
elif i in ['Less than 700,000 yen', '700,000 yen - 1 million yen']:
selectedData['SZINCOMA'].replace(i, 2, inplace=True)
elif i in ['1 million yen - 1.3 million yen',
'1.3 million yen - 1.5 million yen',
'1.5 million yen - 2.5 million yen']:
selectedData['SZINCOMA'].replace(i, 3, inplace=True)
elif i in ['2.5 million yen - 3.5 million yen',
'3.5 million yen - 4.5 million yen',
'4.5 million yen - 5.5 million yen',]:
selectedData['SZINCOMA'].replace(i, 4, inplace=True)
elif i in ['5.5 million yen - 6.5 million yen',
'6.5 million yen - 7.5 million yen',
'7.5 million yen - 8.5 million yen',
'8.5 million yen - 10 million yen',
'10 million yen - 12 million yen',
'12 million yen - 14 million yen',
'14 million yen - 16 million yen',
'16 million yen - 18.5 million yen',
'18.5 million yen - 23 million yen',]:
selectedData['SZINCOMA'].replace(i, 5, inplace=True)
else:
selectedData['SZINCOMA'].replace(i, 0, inplace=True)
selectedData.drop('PREF15', axis=1, inplace=True)
selectedData['TP5LOC15'].replace('Large city', 1, inplace=True)
selectedData['TP5LOC15'].replace('Small to medium sized city', 2, inplace=True)
selectedData['TP5LOC15'].replace('Town', 3, inplace=True)
selectedData['TP5LOC15'].replace('Village', 4, inplace=True)
for i in np.unique(selectedData['PPJBXX15']):
if i == 'managers in companies/organizations':
selectedData['PPJBXX15'].replace(i, 1, inplace=True)
elif i == 'Not applicable':
selectedData['PPJBXX15'].replace(i, 0, inplace=True)
else:
selectedData['PPJBXX15'].replace(i, 2, inplace=True)
selectedData['PPJBSZ15'].replace('1', 1, inplace=True)
selectedData['PPJBSZ15'].replace('Small company (2-29 employees)', 2, inplace=True)
selectedData['PPJBSZ15'].replace('Medium-sized company (30-299 employees)', 3, inplace=True)
selectedData['PPJBSZ15'].replace('Large company (300-999 employees)', 4, inplace=True)
selectedData['PPJBSZ15'].replace('Major company (1000 or more employees', 5, inplace=True)
selectedData['PPJBSZ15'].replace('Government agency', 6, inplace=True)
selectedData['PPJBSZ15'].replace("Don't know", 0, inplace=True)
for i in np.unique(selectedData['MMJBTP15']):
if i == 'She was not working.':
selectedData['MMJBTP15'].replace(i, 1, inplace=True)
elif i == 'Temporary worker, Daily worker, Part-time temporary worker':
selectedData['MMJBTP15'].replace(i, 2, inplace=True)
elif i in ["Regular employee - don't know about occupation",
'Regular employee - managerial position',
'Regular employee - non-management',
'Regular employee - professional (nurse, teacher, etc.)']:
selectedData['MMJBTP15'].replace(i, 3, inplace=True)
elif i in ["Don't know", 'No answer']:
selectedData['MMJBTP15'].replace(i, 0, inplace=True)
else:
selectedData['MMJBTP15'].replace(i, 4, inplace=True)
for i in np.unique(selectedData['XXLSTSCH']):
if i in ['Ordinary elementary school in the old system',
'Higher elementary school in the old system']:
selectedData['XXLSTSCH'].replace(i, 1, inplace=True)
elif i in ["Junior high school/Girls' high school in the old system",
'Vocational school/Commerce school in the old system',
'Normal school in the old system',
'Higher school or vocational school in the old system',
'Junior high school',
'High school']:
selectedData['XXLSTSCH'].replace(i, 2, inplace=True)
elif i in ['No answer', "Don't know"]:
selectedData['XXLSTSCH'].replace(i, 0, inplace=True)
else:
selectedData['XXLSTSCH'].replace(i, 3, inplace=True)
for i in np.unique(selectedData['SSLSTSCH']):
if i in ['Ordinary elementary school in the old system',
'Higher elementary school in the old system']:
selectedData['SSLSTSCH'].replace(i, 1, inplace=True)
elif i in ["Junior high school/Girls' high school in the old system",
'Vocational school/Commerce school in the old system',
'Normal school in the old system',
'Higher school or vocational school in the old system',
'Junior high school',
'High school']:
selectedData['SSLSTSCH'].replace(i, 2, inplace=True)
elif i in ['No answer', "Don't know", 'Never-married/Divorced']:
selectedData['SSLSTSCH'].replace(i, 0, inplace=True)
else:
selectedData['SSLSTSCH'].replace(i, 3, inplace=True)
for i in | np.unique(selectedData['PPLSTSCH']) | numpy.unique |
"""
Library Features:
Name: lib_utils_plot
Author(s): <NAME> (<EMAIL>)
Date: '20220208'
Version: '1.0.0'
"""
#######################################################################################
# Libraries
import logging
import cartopy
import rasterio
import numpy as np
from lib_utils_io import write_file_tif, read_file_tif, save_file_json
from lib_utils_colormap import load
import matplotlib.pylab as plt
import matplotlib.ticker as mticker
import cartopy.io.img_tiles as cimgt
from pyproj import Proj
from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER
from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable
logging.getLogger('rasterio').setLevel(logging.WARNING)
logging.getLogger('matplotlib').setLevel(logging.WARNING)
logging.getLogger('PIL').setLevel(logging.WARNING)
from lib_info_args import logger_name
# Logging
log_stream = logging.getLogger(logger_name)
#######################################################################################
# -------------------------------------------------------------------------------------
# Method to save info data in json format
def save_file_info(file_name, file_data_collections):
save_file_json(file_name, file_data_dict=file_data_collections)
# -------------------------------------------------------------------------------------
# -------------------------------------------------------------------------------------
# Method to read data values from geotiff format
def read_file_tiff(file_name):
file_data, file_proj, file_geotrans = read_file_tif(file_name)
return file_data
# -------------------------------------------------------------------------------------
# -------------------------------------------------------------------------------------
# Method to save data values in geotiff format
def save_file_tiff(file_name, file_data, file_geo_x, file_geo_y, file_metadata=None, file_epsg_code='EPSG:32632'):
if file_metadata is None:
file_metadata = {'description': 'data'}
file_data_height, file_data_width = file_data.shape
file_geo_x_west = | np.min(file_geo_x) | numpy.min |
# -*- coding: utf-8 -*-
"""
Created on Tue Jan 23 11:41:16 2018
This module is an implementation of the (S)ingle (O)bjective (B)inary (G)enetic
(A)lgorithm.
@author: sreimond
"""
import numpy as np
from copy import deepcopy
import itertools
class Population( object ):
"""
The `Population` class holds Individuals and optimizes the objective
function as defined in the config dictionary.
"""
def __init__( self, config ):
self.config = _default_config(config)
self.individuals = []
self.development = {'generation':[],
'function_calls':0,
'best_fitness':[],
'worst_fitness':[],
'mean_fitness':[],
'std_fitness':[]}
self.optimized_parameters = []
self.iteration = 0
def initialize_individuals(self):
for _ in range(self.config['pop_size']):
self.add_individual()
def add_individual(self):
d_min = -np.inf
for ix in range(10):
individual = Individual(self)
if ix==0:
self.individuals.append(individual)
continue
d = []
for individual2 in self.individuals:
if individual == individual2:
continue
d.append( individual.determine_distance(individual2) )
if np.min(d) > d_min:
d_min = np.min(d)
del self.individuals[-1]
self.individuals.append(individual)
def sort_individuals(self):
# fittest indivdual has max. fitness and is located at index 0
neg_fitness = [-individual.development['fitness'][-1] for individual in self.individuals]
neg_feasibility = [-individual.development['feasibility'][-1] for individual in self.individuals]
ix = np.lexsort((neg_fitness,neg_feasibility))
# ix = np.argsort(neg_fitness)
return [self.individuals[jx] for jx in ix]
def update_statistics(self):
fitness = [individual.development['fitness'][-1] for individual in self.individuals]
self.development['generation'].append( self.iteration )
self.development['best_fitness'].append( np.max(fitness) )
self.development['worst_fitness'].append( np.min(fitness) )
self.development['mean_fitness'].append( np.mean(fitness) )
self.development['std_fitness'].append( np.std(fitness) )
def test_individuals(self):
for individual in self.individuals:
individual.determine_fitness()
self.development['function_calls'] += 1
def dismiss_individuals(self):
method = self.config['nsel_method']
pop_size = self.config['pop_size']
rate = self.config['nsel_rate']
thresh = self.config['nsel_thresh']
if method == 'sorted_list':
ix = int(pop_size - pop_size * rate )
ix_dismiss = list(range(ix,pop_size))
elif method == 'thresholding':
ix_dismiss = []
for ix,individual in self.individuals:
if (-individual.development['fitness'][-1]) > thresh:
ix_dismiss.append(ix)
ix_dismiss.sort(reverse=True)
for ix in ix_dismiss:
del self.individuals[ix]
while len(self.individuals)<2:
self.add_individual()
if (pop_size - len(self.individuals)) % 2 != 0:
del self.individuals[-1]
def select_parents(self):
pop_size = int(self.config['pop_size'])
individual_count = len(self.individuals)
missing_count = pop_size-individual_count
parents_count = int(missing_count/2)
participants_count = int(self.config['msel_n_participants'])
method = self.config['msel_method']
do_replace = False
if ((individual_count < missing_count) or
(individual_count < participants_count * 2)):
do_replace = True
if method == 'sorted_list':
ix = range(missing_count)
self.parents = (ix[::2],ix[1::2])
elif method == 'random_picking':
ix = np.random.choice(range(individual_count),
replace=do_replace,
size=missing_count)
self.parents = (ix[0:parents_count],ix[parents_count:missing_count])
elif method == 'tournament':
parent1 = []
parent2 = []
for _ in range(parents_count):
ix = np.random.choice(range(individual_count),
replace=do_replace,
size=participants_count*2)
mums = ix[0:participants_count]
dads = ix[participants_count:participants_count*2]
mums_fitness = [self.individuals[mum].development['fitness'][-1] for mum in mums]
dads_fitness = [self.individuals[dad].development['fitness'][-1] for dad in dads]
parent1.append(mums[np.argmax(mums_fitness)])
parent2.append(dads[np.argmax(dads_fitness)])
self.parents = (parent1,parent2)
def mate_individuals(self):
ix_parents1, ix_parents2 = self.parents
for ix,ix_parent1 in enumerate(ix_parents1):
ix_parent2 = ix_parents2[ix]
parent1 = self.individuals[ix_parent1]
parent2 = self.individuals[ix_parent2]
children = parent1.mate(parent2)
self.individuals.append(children[0])
self.individuals.append(children[1])
def mutate_individuals(self):
ix = 0
if self.config['mut_elitism']:
ix = 1
for jx,individual in enumerate(self.individuals):
if jx < ix:
continue
individual.mutate()
def start_evolution(self):
self.initialize_individuals()
self.test_individuals()
self.individuals = self.sort_individuals()
self.update_statistics()
for _ in range(self.config['max_iterations']-1):
self.iteration += 1
self.dismiss_individuals()
self.select_parents()
self.mate_individuals()
self.mutate_individuals()
self.test_individuals()
self.individuals = self.sort_individuals()
self.update_statistics()
self.optimized_parameters = self.individuals[0].genes
class Individual( object ):
"""
The `Individual` class defines Individuals and assigns Genes.
"""
def __init__(self,population):
self.population = population
self.development = {'generation':[],'fitness':[],'feasibility':[]}
self.initialize()
def initialize(self):
self.genes = []
for parameter in self.population.config['objective_function'].parameters:
gene = deepcopy( parameter )
gene.set_random_value()
self.genes.append( gene )
self.update_dna()
def determine_distance(self,individual):
d = 0
for ix,gene in enumerate(self.genes):
d += (gene.value - individual.genes[ix].value)**2.0
return np.sqrt(d)
def update_dna(self):
dna = [gene.code for gene in self.genes]
self.dna = np.array(list(itertools.chain(*dna)))
def update_genes(self):
ix = 0
for gene in self.genes:
jx = ix + gene.bits
code = self.dna[ix:jx]
gene.set_binary_code(code)
ix = jx
def determine_fitness(self):
cost = self.population.config['objective_function'].evaluate( self.genes )
fitness = -cost
feasibility = self.population.config['objective_function'].determine_feasibility( self.genes )
self.development['generation'].append(self.population.iteration)
self.development['fitness'].append(fitness)
self.development['feasibility'].append(feasibility)
def mutate(self):
total_bits = len(self.dna)
mutations_count = int(np.ceil(total_bits*self.population.config['mut_rate']))
ix = np.random.randint(0,total_bits,mutations_count)
mutations = np.fabs(self.dna[ix] - 1)
self.dna[ix] = mutations
self.update_genes()
def mate(self,individual):
total_bits = len(self.dna)
parents_dna = (self.dna,individual.dna)
children_dna = parents_dna
mask = np.zeros(total_bits,dtype=bool)
if self.population.config['mat_method'] == 'single_point':
ix = np.random.randint(0,total_bits)
mask[0:ix] = True
elif self.population.config['mat_method'] == 'two_point':
ix = np.sort( | np.random.choice(total_bits, 2, replace=False) | numpy.random.choice |
#!/usr/bin/env python
# Version: 1.0
# Author: <NAME> (updated by <NAME>)
from __future__ import division, print_function
import sys, math, os
import numpy as np
import scipy.stats
import datetime
import matplotlib.pyplot as plt
import glob
from collections import deque
import astropy.units as u
from astropy import log
from astropy.io import fits
from astropy.time import Time
from nicer.values import *
from pint.fits_utils import read_fits_event_mjds
from pint.eventstats import h2sig,hm
import argparse
desc= """
Read one or more event files
to sort GTI by background rate
and evaluate H-test
"""
plt.rc('font', size=14) # controls default text sizes
plt.rc('axes', labelsize=13) # fontsize of the x and y labels
plt.rc('xtick', labelsize=13) # fontsize of the tick labels
plt.rc('ytick', labelsize=13) # fontsize of the tick labels
plt.rc('legend', fontsize=14) # legend fontsize
plt.rc('axes', linewidth=1.5)
plt.rc('xtick.major', size=4, width=1.5)
plt.rc('ytick.major', size=4, width=1.5)
parser = argparse.ArgumentParser(description = desc)
#parser.add_argument("evt", help="Input event files using glob.glob (e.g.'10010101*_Proc/cleanfilt_par.evt')")
parser.add_argument("infile", help="file or text file with list of event file", nargs='+')
parser.add_argument("outfile", help="name for output files")
parser.add_argument("--emin", help="Minimum energy to include (keV, default=0.25)", type=float, default=0.25)
parser.add_argument("--emax", help="Maximum energy to include (keV, default=2.00)", type=float, default=2.00)
parser.add_argument("--gridsearch", help="Search over energies to find max H-test", action="store_true",default=False)
parser.add_argument("--coarsegridsearch", help="Search over energies to find max H-test", action="store_true",default=False)
parser.add_argument("--savefile", help="Saving optimized event file", action="store_true",default=False)
parser.add_argument("--nbins", help="Number of bins for plotting pulse profile (default=16)", type=int, default=16)
parser.add_argument("--name", help="Pulsar name for output figure", type=str, default='')
args = parser.parse_args()
def load_files(fnames):
# make a comprehensive list of gtis/rates
gtis = deque()
times = deque()
pis = deque()
phases = deque()
for fname in fnames:
f = fits.open(fname)
t0s = f['gti'].data.field('start')
t1s = f['gti'].data.field('stop')
for t0,t1 in zip(t0s,t1s):
gtis.append([t0,t1])
times.append(f['events'].data.field('time'))
pis.append(f['events'].data.field('pi'))
try:
phases.append(f['events'].data.field('pulse_phase'))
except:
pass
times = np.concatenate(times)
pis = np.concatenate(pis)
if len(phases) > 0:
phases = np.concatenate(phases)
else:
phases = None
t0s,t1s = np.asarray(list(gtis)).transpose()
return times,phases,pis,t0s,t1s
def dice_gtis(data,tmax=100):
""" Break larger GTIs into small pieces to handle rate variations."""
times,phases,pis,t0s,t1s = data
new_t0s = deque()
new_t1s = deque()
for t0,t1 in zip(t0s,t1s):
dt = t1-t0
if dt < tmax:
new_t0s.append(t0)
new_t1s.append(t1)
else:
# break up GTI in such a way to avoid losing time (to tmin) and
# to avoid having pieces longer than tmax
npiece = int(np.floor(dt/tmax))+1
new_edges = np.linspace(t0,t1,npiece+1)
for it0,it1 in zip(new_edges[:-1],new_edges[1:]):
new_t0s.append(it0)
new_t1s.append(it1)
return times,phases,pis,np.asarray(new_t0s),np.asarray(new_t1s)
def ensemble_htest(phases,slices,m=20,c=4):
""" Calculate H-test statistic for subsets of a set of phases.
Cache intermediate products to avoid O(N^2) complexity!
"""
phases = np.asarray(phases)*(2*np.pi) # in radians and copy
cache = np.empty((2*m,len(phases)))
for i in range(m):
cache[2*i] = np.cos((i+1)*phases)
cache[2*i+1] = np.sin((i+1)*phases)
rvals = np.empty(len(slices))
penalty = c*np.arange(0,m)
for isl,sl in enumerate(slices):
x = cache[:,sl]
nph = x.shape[1]
if nph == 0:
rvals[isl] = 0.01
continue
t = np.sum(cache[:,sl],axis=1)**2
t = np.cumsum(t[::2] + t[1::2])*(2./nph)
rvals[isl] = np.max(t-penalty)
return rvals
def make_sn(data,mask=None,rate=0.1,min_gti=5):
""" data -- output of load_local
mask -- optional mask to select events (e.g. on PI)
rate -- assumed rate for S/N calculation in ct/sec
min_gti -- minimum GTI length in seconds
"""
times,phases,pis,t0s,t1s = data
if mask is not None:
times = times[mask]
phases = phases[mask]
pis = pis[mask]
# determine which gti each event belongs to
gti_idx = np.searchsorted(t1s,times)
# count events in each gti
gti_cts = np.bincount(gti_idx,minlength=len(t1s))
gti_len = t1s-t0s
mask = gti_len > min_gti
rates = (gti_cts / gti_len)[mask]
a = np.argsort(rates)
gti_len_s = gti_len[mask][a]
gti_cts_s = gti_cts[mask][a]
gti_rts_s = gti_cts_s/gti_len_s
sn = rate*np.cumsum(gti_len_s)/np.sqrt(np.cumsum(gti_cts_s)+rate*gti_len_s)
rate = 0
sn0 = np.cumsum(gti_len_s)/np.sqrt(np.cumsum(gti_cts_s))
if phases is not None:
counter = 0
ph_gti = deque()
for i,ct in enumerate(gti_cts):
ph_gti.append(phases[counter:counter+ct])
counter += ct
# apply mask
ph_gti = [ph_gti[i] for i,imask in enumerate(mask) if imask]
# apply sorting
ph_gti = [ph_gti[i] for i in a]
# make a set of slices
nph = np.cumsum([len(phg) for phg in ph_gti])
slices = [slice(0,n) for n in nph]
assert(len(slices)==len(ph_gti))
# calculate H test
hs = ensemble_htest(np.concatenate(ph_gti),slices)
else:
hs = None
ph_gti = None
return sn,sn0,hs,ph_gti,gti_rts_s,gti_len_s
## UNUSED...
def get_optimal_cuts(data,pred_rate = 0.017):
""" Determine rates from analytic prediction for both 0.25 and 0.40 keV
cuts, and use these to estimate an optimal H test.
"""
pi_mask = (data[2]>25) & (data[2]<100)
sn,sn0,hs,ph_gti,gti_rts_s,gti_len_s = make_sn(data,mask=pi_mask,rate=pred_rate)
amax = np.argmax(sn)
pi_mask = (data[2]>40) & (data[2]<100)
pred_rate *= 3./5
sn_40,sn0_40,hs_40,ph_gti_40,gti_rts_s_40,gti_len_s_40 = make_sn(data,mask=pi_mask,rate=pred_rate)
hsig_40 = [h2sig(h) for h in hs]
exposure = np.cumsum(gti_len_s)
amax_40 = np.argmax(sn_40)
# get intersection of 0.25 keV data sets and 0.4 keV data sets
rate_025_cut = gti_rts_s[amax]
rate_040_cut = gti_rts_s_40[amax_40]
mask_025 = gti_rts_s<=rate_025_cut
mask_040 = ~mask_025 & (gti_rts_s_40<rate_040_cut)
ph1 = np.concatenate(np.asarray(ph_gti)[mask_025])
try:
ph2 = np.concatenate(np.asarray(ph_gti_40)[mask_040])
except ValueError:
ph2 = np.asarray([])
print('Found %d photons satisfying 0.25 keV cut; exposure = %.1fs'%(len(ph1),np.sum(np.asarray(gti_len_s)[mask_025])))
print('Found %d photons satisfying 0.40 keV cut; exposure = %.1fs'%(len(ph2),np.sum(np.asarray(gti_len_s_40)[mask_040])))
print('H-test 1: %.2f'%hm(ph1))
if len(ph2)>0:
print('H-test 2: %.2f'%hm(ph2))
else:
print('H-test 2: no photons!')
print('H-test joint: %.2f'%hm(np.append(ph1,ph2)))
if len(args.infile)==1:
if args.infile[0].startswith('@'):
inputfile = args.infile[0].split('@')[1]
log.info('Reading input ObsID list: {}'.format(inputfile))
all_files = np.loadtxt(inputfile,dtype=str)
else:
all_files = args.infile
else:
all_files = args.infile
data = load_files(all_files)
data_diced = dice_gtis(data)
#get_optimal_cuts(data_diced)
if args.gridsearch:
all_emin = np.arange(0.24,1.0,0.01)
elif args.coarsegridsearch:
all_emin = np.arange(0.3,2.0,0.1)
else:
all_emin = np.array([args.emin])
hbest = 0.0
eminbest = 0.0
emaxbest = 100.0
eminlist = []
emaxlist = []
hgrid = []
for emin in all_emin:
if args.gridsearch:
all_emax = np.arange(1.0,3.0,0.01)
elif args.coarsegridsearch:
all_emax = np.arange(emin+0.1,7.0,0.2)
else:
all_emax = np.array([args.emax])
for emax in all_emax:
print("Energy range: {:0.2f}-{:0.2f} keV".format(emin,emax))
pi_mask = (data[2]>emin*KEV_TO_PI) & (data[2]<emax*KEV_TO_PI)
pred_rate = 0.05/10.0 # 2241
sn,sn0,hs,ph_gti,gti_rts_s,gti_len_s = make_sn(data_diced,mask=pi_mask,rate=pred_rate)
hsig = [h2sig(h) for h in hs]
exposure = np.cumsum(gti_len_s)
plt.figure(5); plt.clf()
# scale exposure to the expected S/N
amax = np.argmax(sn)
exposure_scale = sn[amax]/exposure[amax]**0.5
Hmax = np.argmax(hsig)
if not args.gridsearch and not args.coarsegridsearch:
#plt.plot(gti_rts_s,exposure**0.5*exposure_scale,label='scaled exposure')
#plt.plot(gti_rts_s,sn,label='predicted S/N')
plt.plot(gti_rts_s,hsig,label='H-test significance')
plt.axvline(gti_rts_s[amax],color='k',ls='--')
plt.axvline(gti_rts_s[Hmax],color='r',ls='--')
plt.xlabel('Background Rate (ct/s)')
plt.ylabel('Significance (sigma)')
plt.title('{} - [{},{}]'.format(args.name,emin,emax))
plt.legend(loc='lower right')
plt.savefig('{}_sig.png'.format(args.outfile))
plt.clf()
nbins=args.nbins
select_ph = np.concatenate(ph_gti[:Hmax]).ravel()
profbins = np.linspace(0.0,1.0,nbins+1,endpoint=True)
profile, edges = np.histogram(select_ph,bins=profbins)
bbins = np.concatenate((profbins, profbins[1:]+1.0, profbins[1:]+2.0))
fullprof = np.concatenate((profile,profile,profile, | np.array([profile[0]]) | numpy.array |
# -*- coding: utf-8 -*-
"""
The project implements Reinforcement Learning
(specifically, Finite Action-set Learning Automata)
to tune the PID controller gains of a simulated Quadcopter
+ multi-vehicle
+ obstacle avoidance using potential fields
+ plus an improvement on potential fields using shifting planar inequalities
Full documentation here:
https://github.com/tjards/Quadcopter_multi
editing author: <NAME>, PhD
email: <EMAIL>
The vehicle dynamics, controllers, and other files have been modified from the
original implementation of:
author: <NAME>
email: <EMAIL>
license: MIT
Please feel free to use and modify this, but keep the above information. Thanks!
"""
# Import stuff
# ------------
import numpy as np
import matplotlib.pyplot as plt
import time
#import cProfile
from trajectory import Trajectory
from ctrl import Control
from quadFiles.quad import Quadcopter
from utils.windModel import Wind
import utils
#import config as simConfig
# my libraries
from fala import falaObj
from potentialField import potentialField as pf
import utils.collectData as collect
import config as simConfig
import utils.shiftingPIC as QP
from utils.animation import sameAxisAnimation as sameAxisAnimation
#from utils.animation2 import sameAxisAnimation2 as sameAxisAnimation2
from utils.animation_n import sameAxisAnimationN as sameAxisAnimationN
# This function integrates the control inputs through the dynamics
# ----------------------------------------------------------------
def quad_sim(t, Ts, quad, ctrl, wind, traj, fala, obsPF, config):
# Hard code the learned params
# ----------------------------
# these are bad ones:
# #selPars = np.array([1,6,3,6,0,6,0,2,0,1,5,4,0,2])
# selPars = np.array([1,1,1,1,1,1,1,1,1,1,1,1,1,1])
# for i in range(0,config.nParams):
# fala.selectedVals[0,i] = fala.optionsTable[selPars[i],i]
# ctrl.tune(fala.selectedVals.transpose().ravel(), [1, 1, 1, 1])
# Dynamics (using last timestep's commands)
# ---------------------------
quad.update(t, Ts, ctrl.w_cmd, wind, config)
t += Ts
# Learn from the trial (if selected)
# ---------------------------------
if fala.doLearn != 0:
fala.learn(quad,traj,ctrl,Ts,t)
# Trajectory for Desired States (for next iteration)
# -------------------------------------------------
sDes = traj.desiredState(t, Ts, quad)
# Use PIC shifting to move target (if enabled)
# ---------------------------------------------
if config.PIC:
xv = np.reshape(quad.state[0:3], (1,3))
xt = np.reshape(traj.sDes[0:3], (1,3))
cx = QP.moveTarget(quad.state, obsPF.Po, xv, xt, 0.1, 0.1, config.obsRad)
traj.sDes[0:3] = np.array(cx['x'][:])
# Avoid obstacles using potential fields (if enabled)
# ---------------------------------------------------
if config.PF:
obsPF.updateTraj(quad.state[0:3],traj.sDes[0:3],traj)
# Generate Commands (for next iteration)
# --------------------------------------
ctrl.controller(traj, quad, sDes, config)
return t
# This is the main function
# --------------------------
def main():
start_time = time.time()
# Import the simulation setup
# ---------------------------
config=simConfig.config()
# Initialize wind (untested)
# --------------------------
wind = Wind('None', 2.0, 90, -15)
# Initialize list for objects
# ---------------------------
numTimeStep = int(config.Tf/config.Ts+1)
quadList = []
trajList = []
ctrlList = []
sDesList = []
obsPFList = []
myDataList = []
# For the number of vehicles
# --------------------------
for objectIndex in range(0,config.nVeh):
quadList.append(Quadcopter(config))
trajList.append(Trajectory(quadList[objectIndex], config.ctrlType, config.trajSelect, config))
ctrlList.append(Control(quadList[objectIndex], trajList[objectIndex].yawType))
sDesList.append(trajList[objectIndex].desiredState(0, config.Ts, quadList[objectIndex]) )
obsPFList.append(pf(trajList[objectIndex], np.vstack((config.o1,config.o2,config.o3,quadList[objectIndex-1].state[0:3])).transpose() , gamma=config.gamma, eta=config.eta, obsRad=config.obsRad, obsRange = config.obsRange))
# generate first command
ctrlList[objectIndex].controller(trajList[objectIndex], quadList[objectIndex], sDesList[objectIndex], config)
# Create learning object
# ---------------------------
fala = falaObj(config)
# Initialize Result Matrixes
# ---------------------------
for objectIndex in range(0,config.nVeh):
# initialize result matrices
myDataList.append(collect.quadata(quadList[objectIndex], trajList[objectIndex], ctrlList[objectIndex], fala, config.Ti, numTimeStep))
# Run Simulation
# ---------------------------
t = config.Ti*np.ones(config.nVeh)
i = 1
while round(t[0],3) < config.Tf:
# Update the obstacle positions
# -----------------------------
if t[0] > 0.1:
# recall these, as they could move with time
o1 = config.o1 # np.array([-2.1, 0, -3],) # obstacle 1 (x,y,z)
o2 = config.o2 # np.array([2, -1.2, 0.9]) # obstacle 2 (x,y,z)
o3 = config.o3 # np.array([0, 2.5, -2.5]) # obstacle 2 (x,y,z)
# if just one vehicle
if config.nVeh == 1:
obsPFList[0].Po = | np.vstack((o1,o2,o3)) | numpy.vstack |
"""Film Mode Matching Mode Solver
Implementation of the Film Mode Matching (FMM) algorithm, as described in:
- Sudbo, "Film mode matching a versatile numerical method for vector mode field calculations in dielectric waveguides", Pure App. Optics, 2 (1993), 211-233
- Sudbo, "Improved formulation of the film mode matching method for mode field calculations in dielectric waveguides", Pure App. Optics, 3 (1994), 381-388
Examples
========
See L{FMM1d} and L{FMM2d}.
"""
from __future__ import print_function
from builtins import zip
from builtins import range
from builtins import object
from functools import reduce
__author__ = '<NAME> & <NAME>'
import numpy
import scipy
import scipy.optimize
import copy
import EMpy.utils
from EMpy.modesolvers.interface import *
import pylab
class Message(object):
def __init__(self, msg, verbosity=0):
self.msg = msg
self.verbosity = verbosity
def show(self, verbosity=0):
if self.verbosity <= verbosity:
print((self.verbosity - 1) * '\t' + self.msg)
class Struct(object):
"""Empty class to fill with whatever I want. Maybe a dictionary would do?"""
pass
class Boundary(object):
"""Boundary conditions.
Electric and Magnetic boundary conditions are translated to Symmetric
and Antisymmetric for each field.
@ivar xleft: Left bc on x.
@ivar xright: Right bc on x.
@ivar yleft: Left bc on y.
@ivar yright: Right bc on y.
"""
def __init__(self, xleft='Electric Wall',
yleft='Magnetic Wall',
xright='Electric Wall',
yright='Magnetic Wall'):
"""Set the boundary conditions, validate and translate."""
self.xleft = xleft
self.yleft = yleft
self.xright = xright
self.yright = yright
self.validate()
self.translate()
def validate(self):
"""Validate the input.
@raise ValueError: Unknown boundary.
"""
if not reduce(lambda x, y: x & y,
[(x == 'Electric Wall') | (x == 'Magnetic Wall') for x in [self.xleft, self.yleft, self.xright, self.yright]]):
raise ValueError('Unknown boundary.')
def translate(self):
"""Translate for each field.
@raise ValueError: Unknown boundary.
"""
self.xh = ''
self.xe = ''
self.yh = ''
self.ye = ''
if self.xleft == 'Electric Wall':
self.xh += 'A'
self.xe += 'S'
elif self.xleft == 'Magnetic Wall':
self.xh += 'S'
self.xe += 'A'
else:
raise ValueError('Unknown boundary.')
if self.xright == 'Electric Wall':
self.xh += 'A'
self.xe += 'S'
elif self.xright == 'Magnetic Wall':
self.xh += 'S'
self.xe += 'A'
else:
raise ValueError('Unknown boundary.')
if self.yleft == 'Electric Wall':
self.yh += 'A'
self.ye += 'S'
elif self.yleft == 'Magnetic Wall':
self.yh += 'S'
self.ye += 'A'
else:
raise ValueError('Unknown boundary.')
if self.yright == 'Electric Wall':
self.yh += 'A'
self.ye += 'S'
elif self.yright == 'Magnetic Wall':
self.yh += 'S'
self.ye += 'A'
else:
raise ValueError('Unknown boundary.')
def __str__(self):
return 'xleft = %s, xright = %s, yleft = %s, yright = %s' % (self.xleft, self.xright, self.yleft, self.yright)
class Slice(object):
"""One dimensional arrangement of layers and 1d modes.
A slice is made of a stack of layers, i.e. refractive indeces with a thickness,
with given boundary conditions.
It holds 1d modes, both TE and TM.
@ivar x1: start point of the slice in x.
@ivar x2: end point of the slice in x.
@ivar Uy: array of points delimiting the layers.
@ivar boundary: boundary conditions.
@ivar modie: E modes.
@ivar modih: H modes.
@ivar Ux: array of points delimiting the slices in x (internally set).
@ivar refractiveindex: refractive index of all the slices (internally set).
@ivar epsilon: epsilon of all the slices (internally set).
@ivar wl: vacuum wavelength.
"""
def __init__(self, x1, x2, Uy, boundary, modie, modih):
self.x1 = x1
self.x2 = x2
self.Uy = Uy
self.boundary = boundary
self.modie = modie
self.modih = modih
def __str__(self):
return 'x1 = %g, x2 = %g\nUy = %s\nboundary = %s' % (self.x1, self.x2, self.Uy, self.boundary)
class FMMMode1d(Mode):
"""One dimensional mode.
Note
====
Virtual class.
"""
pass
class FMMMode1dx(FMMMode1d):
"""Matching coefficients in the x-direction.
L{FMMMode1dy}s are weighted by these coefficients to assure continuity.
"""
def __str__(self):
return 'sl = %s\nsr = %s\nal = %s\nar = %s\nk = %s\nU = %s' % \
(self.sl.__str__(),
self.sr.__str__(),
self.al.__str__(),
self.ar.__str__(),
self.k.__str__(),
self.U.__str__())
class FMMMode1dy(FMMMode1d):
"""One dimensional mode.
It holds the coefficients that describe the mode in the FMM expansion.
Note
====
The mode is suppose one dimensional, in the y direction.
@ivar sl: array of value of the mode at the lhs of each slice.
@ivar sr: array of value of the mode at the rhs of each slice.
@ivar al: array of value of the derivative of the mode at the lhs of each slice.
@ivar ar: array of value of the derivative of the mode at the lhs of each slice.
@ivar k: wavevector inside each layer.
@ivar keff: effective wavevector.
@ivar zero: how good the mode is? it must be as close to zero as possible!
@ivar Uy: array of points delimiting the layers.
"""
def eval(self, y_):
"""Evaluate the mode at y."""
y = numpy.atleast_1d(y_)
ny = len(y)
f = numpy.zeros(ny, dtype=complex)
for iU in range(len(self.U) - 1):
k = self.k[iU]
sl = self.sl[iU]
al = self.al[iU]
Ul = self.U[iU]
Ur = self.U[iU+1]
idx = numpy.where((Ul <= y) & (y <= Ur))
yy = y[idx] - Ul
f[idx] = sl * numpy.cos(k * yy) + al * sinxsux(k * yy) * yy
return f
def plot(self, y):
f = self.eval(y)
pylab.plot(y, numpy.real(f), y, numpy.imag(y))
pylab.legend(('real', 'imag'))
pylab.xlabel('y')
pylab.ylabel('mode1d')
pylab.show()
def __str__(self):
return 'sl = %s\nsr = %s\nal = %s\nar = %s\nk = %s\nkeff = %s\nzero = %s\nU = %s' % \
(self.sl.__str__(),
self.sr.__str__(),
self.al.__str__(),
self.ar.__str__(),
self.k.__str__(),
self.keff.__str__(),
self.zero.__str__(),
self.U.__str__())
class FMMMode2d(Mode):
"""Two dimensional mode.
It holds the coefficients that describe the mode in the FMM expansion.
"""
def get_x(self, n=100):
return numpy.linspace(self.slicesx[0].Ux[0], self.slicesx[0].Ux[-1], n)
def get_y(self, n=100):
return numpy.linspace(self.slicesx[0].Uy[0], self.slicesx[0].Uy[-1], n)
def eval(self, x_=None, y_=None):
"""Evaluate the mode at x,y."""
if x_ is None:
x = self.get_x()
else:
x = numpy.atleast_1d(x_)
if y_ is None:
y = self.get_y()
else:
y = numpy.atleast_1d(y_)
nmodi = len(self.modie)
lenx = len(x)
leny = len(y)
k0 = 2. * numpy.pi / self.slicesx[0].wl
kz = self.keff
uh = numpy.zeros((nmodi, lenx), dtype=complex)
ue = numpy.zeros_like(uh)
udoth = numpy.zeros_like(uh)
udote = numpy.zeros_like(uh)
Exsh = numpy.zeros((leny, nmodi), dtype=complex)
Exah = numpy.zeros_like(Exsh)
Exse = numpy.zeros_like(Exsh)
Exae = numpy.zeros_like(Exsh)
Eysh = numpy.zeros_like(Exsh)
Eyah = numpy.zeros_like(Exsh)
Eyse = numpy.zeros_like(Exsh)
Eyae = numpy.zeros_like(Exsh)
Ezsh = numpy.zeros_like(Exsh)
Ezah = numpy.zeros_like(Exsh)
Ezse = numpy.zeros_like(Exsh)
Ezae = numpy.zeros_like(Exsh)
cBxsh = numpy.zeros_like(Exsh)
cBxah = numpy.zeros_like(Exsh)
cBxse = numpy.zeros_like(Exsh)
cBxae = numpy.zeros_like(Exsh)
cBysh = numpy.zeros_like(Exsh)
cByah = numpy.zeros_like(Exsh)
cByse = numpy.zeros_like(Exsh)
cByae = numpy.zeros_like(Exsh)
cBzsh = numpy.zeros_like(Exsh)
cBzah = numpy.zeros_like(Exsh)
cBzse = numpy.zeros_like(Exsh)
cBzae = numpy.zeros_like(Exsh)
ExTE = numpy.zeros((leny,lenx), dtype=complex)
EyTE = numpy.zeros_like(ExTE)
EzTE = numpy.zeros_like(ExTE)
ExTM = numpy.zeros_like(ExTE)
EyTM = numpy.zeros_like(ExTE)
EzTM = numpy.zeros_like(ExTE)
cBxTE = numpy.zeros_like(ExTE)
cByTE = numpy.zeros_like(ExTE)
cBzTE = numpy.zeros_like(ExTE)
cBxTM = numpy.zeros_like(ExTE)
cByTM = numpy.zeros_like(ExTE)
cBzTM = numpy.zeros_like(ExTE)
for mx, slice in enumerate(self.slicesx):
idx = numpy.where((slice.x1 <= x) & (x < slice.x2))
x2 = x[idx] - slice.x1
x1 = slice.x2 - x[idx]
dx = slice.x2 - slice.x1
for n in range(nmodi):
fi = slice.modih[n].eval(y)
fidot = dot(slice.modih[n]).eval(y)
psi = slice.modie[n].eval(y)
psisueps = sueps(slice.modie[n]).eval(y)
psidotsueps = sueps(dot(slice.modie[n])).eval(y)
kfh = self.modih[n].k[mx]
kxh = scipy.sqrt(kfh**2 - kz**2)
sl = self.modih[n].sl[mx] * (k0/kfh)**2
al = self.modih[n].al[mx]
sr = self.modih[n].sr[mx] * (k0/kfh)**2
ar = self.modih[n].ar[mx]
uh[n,idx] = (numpy.sin(kxh * x1) * sl + numpy.sin(kxh * x2) * sr) / numpy.sin(kxh * dx)
udoth[n,idx] = (numpy.sin(kxh * x1) * al + numpy.sin(kxh * x2) * ar) / numpy.sin(kxh * dx)
kfe = self.modie[n].k[mx]
kxe = scipy.sqrt(kfe**2 - kz**2)
sl = self.modie[n].sl[mx] * (k0/kfe)**2
al = self.modie[n].al[mx]
sr = self.modie[n].sr[mx] * (k0/kfe)**2
ar = self.modie[n].ar[mx]
ue[n,idx] = (numpy.sin(kxe * x1) * sl + numpy.sin(kxe * x2) * sr) / numpy.sin(kxe * dx)
udote[n,idx] = (numpy.sin(kxe * x1) * al + numpy.sin(kxe * x2) * ar) / numpy.sin(kxe * dx)
Exsh[:,n] = (kz/k0) * fi
Exah[:,n] = 0
Exse[:,n] = 0
Exae[:,n] = -psidotsueps / k0**2
Eysh[:,n] = 0
Eyah[:,n] = 0
Eyse[:,n] = -(kfe/k0)**2 * psisueps
Eyae[:,n] = 0
Ezsh[:,n] = 0
Ezah[:,n] = -1j * fi / k0
Ezse[:,n] = 1j * kz / k0**2 * psidotsueps
Ezae[:,n] = 0
cBxsh[:,n] = 0
cBxah[:,n] = fidot / k0**2
cBxse[:,n] = kz / k0 * psi
cBxae[:,n] = 0
cBysh[:,n] = (kfh/k0)**2 * fi
cByah[:,n] = 0
cByse[:,n] = 0
cByae[:,n] = 0
cBzsh[:,n] = -1j * kz / k0**2 * fidot
cBzah[:,n] = 0
cBzse[:,n] = 0
cBzae[:,n] = -1j * psi / k0
ExTE[:,idx] = numpy.tensordot(Exsh, uh[:,idx], axes=1) + numpy.tensordot(Exah, udoth[:,idx], axes=1)
ExTM[:,idx] = numpy.tensordot(Exse, ue[:,idx], axes=1) + numpy.tensordot(Exae, udote[:,idx], axes=1)
EyTE[:,idx] = numpy.tensordot(Eysh, uh[:,idx], axes=1) + numpy.tensordot(Eyah, udoth[:,idx], axes=1)
EyTM[:,idx] = numpy.tensordot(Eyse, ue[:,idx], axes=1) + numpy.tensordot(Eyae, udote[:,idx], axes=1)
EzTE[:,idx] = numpy.tensordot(Ezsh, uh[:,idx], axes=1) + numpy.tensordot(Ezah, udoth[:,idx], axes=1)
EzTM[:,idx] = numpy.tensordot(Ezse, ue[:,idx], axes=1) + numpy.tensordot(Ezae, udote[:,idx], axes=1)
cBxTE[:,idx] = numpy.tensordot(cBxsh, uh[:,idx], axes=1) + numpy.tensordot(cBxah, udoth[:,idx], axes=1)
cBxTM[:,idx] = numpy.tensordot(cBxse, ue[:,idx], axes=1) + numpy.tensordot(cBxae, udote[:,idx], axes=1)
cByTE[:,idx] = numpy.tensordot(cBysh, uh[:,idx], axes=1) + numpy.tensordot(cByah, udoth[:,idx], axes=1)
cByTM[:,idx] = numpy.tensordot(cByse, ue[:,idx], axes=1) + numpy.tensordot(cByae, udote[:,idx], axes=1)
cBzTE[:,idx] = numpy.tensordot(cBzsh, uh[:,idx], axes=1) + numpy.tensordot(cBzah, udoth[:,idx], axes=1)
cBzTM[:,idx] = numpy.tensordot(cBzse, ue[:,idx], axes=1) + numpy.tensordot(cBzae, udote[:,idx], axes=1)
return (ExTE, ExTM, EyTE, EyTM, EzTE, EzTM, cBxTE, cBxTM, cByTE, cByTM, cBzTE, cBzTM)
def fields(self, x=None, y=None):
ExTE, ExTM, EyTE, EyTM, EzTE, EzTM, cBxTE, cBxTM, cByTE, cByTM, cBzTE, cBzTM = self.eval(x, y)
Ex = ExTE + ExTM
Ey = EyTE + EyTM
Ez = EzTE + EzTM
cBx = cBxTE + cBxTM
cBy = cByTE + cByTM
cBz = cBzTE + cBzTM
return (Ex, Ey, Ez, cBx, cBy, cBz)
def intensity(self, x=None, y=None):
Ex, Ey, Ez, cBx, cBy, cBz = self.fields(x, y)
cSz = .5 * (Ex * numpy.conj(cBy) - Ey * numpy.conj(cBx))
return cSz
def TEfrac_old(self, x_=None, y_=None):
if x_ is None:
x = self.get_x()
else:
x = numpy.atleast_1d(x_)
if y_ is None:
y = self.get_y()
else:
y = numpy.atleast_1d(y_)
Ex, Ey, Ez, cBx, cBy, cBz, cSz = self.fields(x, y)
cSTE = .5 * EMpy.utils.trapz2(Ex * numpy.conj(cBy), y, x)
cSTM = .5 * EMpy.utils.trapz2(-Ey * numpy.conj(cBx), y, x)
return numpy.abs(cSTE) / (numpy.abs(cSTE) + numpy.abs(cSTM))
def TEfrac(self):
Sx, Sy = self.__overlap(self)
return Sx / (Sx - Sy)
def overlap_old(self, m, x_=None, y_=None):
if x_ is None:
x = self.get_x()
else:
x = numpy.atleast_1d(x_)
if y_ is None:
y = self.get_y()
else:
y = numpy.atleast_1d(y_)
Ex, Ey, Ez, cBx, cBy, cBz = self.fields(x, y)
cSz = self.intensity(x, y)
norm = scipy.sqrt(EMpy.utils.trapz2(cSz, y, x))
Ex1, Ey1, Ez1, cBx1, cBy1, cBz1 = m.fields(x, y)
cSz1 = m.intensity(x, y)
norm1 = scipy.sqrt(EMpy.utils.trapz2(cSz1, y, x))
return .5 * EMpy.utils.trapz2(Ex/norm * numpy.conj(cBy1/norm1) - Ey/norm * numpy.conj(cBx1/norm1), y, x)
def __overlap_old(self, mode):
nmodi = len(self.modie)
k0 = 2. * numpy.pi / self.slicesx[0].wl
kz = self.keff
Sx = 0j
Sy = 0j
for mx, slice in enumerate(self.slicesx):
for n1 in range(nmodi):
phi_n1 = slice.modih[n1]
phidot_n1 = dot(phi_n1)
psi_n1 = slice.modie[n1]
psisueps_n1 = sueps(psi_n1)
psidotsueps_n1 = sueps(dot(psi_n1))
uh_n1 = copy.deepcopy(self.modih[n1])
# reduce to a single slice
kfh_n1 = uh_n1.k[mx]
uh_n1.k = numpy.atleast_1d(scipy.sqrt(kfh_n1**2 - kz**2))
uh_n1.sl = numpy.atleast_1d(uh_n1.sl[mx] * (k0/kfh_n1)**2)
uh_n1.al = numpy.atleast_1d(uh_n1.al[mx])
uh_n1.sr = numpy.atleast_1d(uh_n1.sr[mx] * (k0/kfh_n1)**2)
uh_n1.ar = numpy.atleast_1d(uh_n1.ar[mx])
uh_n1.U = numpy.atleast_1d(uh_n1.U[mx:mx+2])
uhdot_n1 = dot(uh_n1)
ue_n1 = copy.deepcopy(self.modie[n1])
# reduce to a single slice
kfe_n1 = ue_n1.k[mx]
ue_n1.k = numpy.atleast_1d(scipy.sqrt(kfe_n1**2 - kz**2))
ue_n1.sl = numpy.atleast_1d(ue_n1.sl[mx] * (k0/kfe_n1)**2)
ue_n1.al = numpy.atleast_1d(ue_n1.al[mx])
ue_n1.sr = numpy.atleast_1d(ue_n1.sr[mx] * (k0/kfe_n1)**2)
ue_n1.ar = numpy.atleast_1d(ue_n1.ar[mx])
ue_n1.U = numpy.atleast_1d(ue_n1.U[mx:mx+2])
uedot_n1 = dot(ue_n1)
for n2 in range(nmodi):
phi_n2 = mode.slicesx[mx].modih[n2]
phidot_n2 = dot(phi_n2)
psi_n2 = mode.slicesx[mx].modie[n2]
psisueps_n2 = sueps(psi_n2)
psidotsueps_n2 = sueps(dot(psi_n2))
uh_n2 = copy.deepcopy(mode.modih[n2])
# reduce to a single slice
kfh_n2 = uh_n2.k[mx]
uh_n2.k = numpy.atleast_1d(scipy.sqrt(kfh_n2**2 - kz**2))
uh_n2.sl = numpy.atleast_1d(uh_n2.sl[mx] * (k0/kfh_n2)**2)
uh_n2.al = numpy.atleast_1d(uh_n2.al[mx])
uh_n2.sr = numpy.atleast_1d(uh_n2.sr[mx] * (k0/kfh_n2)**2)
uh_n2.ar = numpy.atleast_1d(uh_n2.ar[mx])
uh_n2.U = numpy.atleast_1d(uh_n2.U[mx:mx+2])
uhdot_n2 = dot(uh_n2)
ue_n2 = copy.deepcopy(mode.modie[n2])
# reduce to a single slice
kfe_n2 = ue_n2.k[mx]
ue_n2.k = numpy.atleast_1d(scipy.sqrt(kfe_n2**2 - kz**2))
ue_n2.sl = numpy.atleast_1d(ue_n2.sl[mx] * (k0/kfe_n2)**2)
ue_n2.al = numpy.atleast_1d(ue_n2.al[mx])
ue_n2.sr = numpy.atleast_1d(ue_n2.sr[mx] * (k0/kfe_n2)**2)
ue_n2.ar = numpy.atleast_1d(ue_n2.ar[mx])
ue_n2.U = numpy.atleast_1d(ue_n2.U[mx:mx+2])
uedot_n2 = dot(ue_n2)
Sx += kz * kfh_n2**2 / k0**3 * scalarprod(uh_n1, uh_n2) * scalarprod(phi_n1, phi_n2) \
- kfh_n2**2 / k0**4 * scalarprod(uedot_n1, uh_n2) * scalarprod(psidotsueps_n1, phi_n2)
Sy += kfe_n1**2 * kz / k0**3 * scalarprod(ue_n1, ue_n2) * scalarprod(psisueps_n1, psi_n2) \
+ kfe_n1**2 / k0**4 * scalarprod(ue_n1, uhdot_n2) * scalarprod(psisueps_n1, phidot_n2)
return (Sx, Sy)
def __overlap(self, mode):
nmodi = len(self.modie)
k0 = 2. * numpy.pi / self.slicesx[0].wl
kz = self.keff
Sx = 0j
Sy = 0j
for mx, slice in enumerate(self.slicesx):
phi_n1s = []
phidot_n1s = []
psi_n1s = []
psisueps_n1s = []
psidotsueps_n1s = []
uh_n1s = []
uhdot_n1s = []
ue_n1s = []
uedot_n1s = []
kfe_n1s = []
kfh_n1s = []
phi_n2s = []
phidot_n2s = []
psi_n2s = []
psisueps_n2s = []
psidotsueps_n2s = []
uh_n2s = []
uhdot_n2s = []
ue_n2s = []
uedot_n2s = []
kfe_n2s = []
kfh_n2s = []
for n1 in range(nmodi):
phi_n1 = slice.modih[n1]
phi_n1s.append(phi_n1)
phidot_n1s.append(dot(phi_n1))
psi_n1 = slice.modie[n1]
psi_n1s.append(psi_n1)
psisueps_n1s.append(sueps(psi_n1))
psidotsueps_n1s.append(sueps(dot(psi_n1)))
uh_n1 = copy.deepcopy(self.modih[n1])
# reduce to a single slice
kfh_n1 = uh_n1.k[mx]
kfh_n1s.append(kfh_n1)
uh_n1.k = numpy.atleast_1d(scipy.sqrt(kfh_n1**2 - kz**2))
uh_n1.sl = numpy.atleast_1d(uh_n1.sl[mx] * (k0/kfh_n1)**2)
uh_n1.al = numpy.atleast_1d(uh_n1.al[mx])
uh_n1.sr = numpy.atleast_1d(uh_n1.sr[mx] * (k0/kfh_n1)**2)
uh_n1.ar = numpy.atleast_1d(uh_n1.ar[mx])
uh_n1.U = numpy.atleast_1d(uh_n1.U[mx:mx+2])
uh_n1s.append(uh_n1)
uhdot_n1s.append(dot(uh_n1))
ue_n1 = copy.deepcopy(self.modie[n1])
# reduce to a single slice
kfe_n1 = ue_n1.k[mx]
kfe_n1s.append(kfe_n1)
ue_n1.k = numpy.atleast_1d(scipy.sqrt(kfe_n1**2 - kz**2))
ue_n1.sl = numpy.atleast_1d(ue_n1.sl[mx] * (k0/kfe_n1)**2)
ue_n1.al = numpy.atleast_1d(ue_n1.al[mx])
ue_n1.sr = numpy.atleast_1d(ue_n1.sr[mx] * (k0/kfe_n1)**2)
ue_n1.ar = numpy.atleast_1d(ue_n1.ar[mx])
ue_n1.U = numpy.atleast_1d(ue_n1.U[mx:mx+2])
ue_n1s.append(ue_n1)
uedot_n1s.append(dot(ue_n1))
phi_n2 = mode.slicesx[mx].modih[n1]
phi_n2s.append(phi_n2)
phidot_n2s.append(dot(phi_n2))
psi_n2 = mode.slicesx[mx].modie[n1]
psi_n2s.append(psi_n2)
psisueps_n2s.append(sueps(psi_n2))
psidotsueps_n2s.append(sueps(dot(psi_n2)))
uh_n2 = copy.deepcopy(mode.modih[n1])
# reduce to a single slice
kfh_n2 = uh_n2.k[mx]
kfh_n2s.append(kfh_n2)
uh_n2.k = numpy.atleast_1d(scipy.sqrt(kfh_n2**2 - kz**2))
uh_n2.sl = numpy.atleast_1d(uh_n2.sl[mx] * (k0/kfh_n2)**2)
uh_n2.al = numpy.atleast_1d(uh_n2.al[mx])
uh_n2.sr = numpy.atleast_1d(uh_n2.sr[mx] * (k0/kfh_n2)**2)
uh_n2.ar = numpy.atleast_1d(uh_n2.ar[mx])
uh_n2.U = numpy.atleast_1d(uh_n2.U[mx:mx+2])
uh_n2s.append(uh_n2)
uhdot_n2s.append(dot(uh_n2))
ue_n2 = copy.deepcopy(mode.modie[n1])
# reduce to a single slice
kfe_n2 = ue_n2.k[mx]
kfe_n2s.append(kfe_n2)
ue_n2.k = numpy.atleast_1d(scipy.sqrt(kfe_n2**2 - kz**2))
ue_n2.sl = numpy.atleast_1d(ue_n2.sl[mx] * (k0/kfe_n2)**2)
ue_n2.al = numpy.atleast_1d(ue_n2.al[mx])
ue_n2.sr = numpy.atleast_1d(ue_n2.sr[mx] * (k0/kfe_n2)**2)
ue_n2.ar = numpy.atleast_1d(ue_n2.ar[mx])
ue_n2.U = numpy.atleast_1d(ue_n2.U[mx:mx+2])
ue_n2s.append(ue_n2)
uedot_n2.append(dot(ue_n2))
for n1 in range(nmodi):
uh_n1 = uh_n1s[n1]
ue_n1 = ue_n1s[n1]
uedot_n1 = uedot_n1s[n1]
phi_n1 = phi_n1s[n1]
psi_n1 = psi_n1s[n1]
psidotsueps_n1 = psidotsueps_n1s[n1]
psisueps_n1 = psisueps_n1s[n1]
kfe_n1 = kfe_n1s[n1]
for n2 in range(nmodi):
uh_n2 = uh_n2s[n2]
uhdot_n2 = uhdot_n2s[n2]
ue_n2 = ue_n2s[n2]
phi_n2 = phi_n2s[n2]
phidot_n2 = phidot_n2s[n2]
psi_n2 = psi_n2s[n2]
kfh_n2 = kfh_n2s[n2]
Sx += kz * kfh_n2**2 / k0**3 * scalarprod(uh_n1, uh_n2) * scalarprod(phi_n1, phi_n2) \
- kfh_n2**2 / k0**4 * scalarprod(uedot_n1, uh_n2) * scalarprod(psidotsueps_n1, phi_n2)
Sy += kfe_n1**2 * kz / k0**3 * scalarprod(ue_n1, ue_n2) * scalarprod(psisueps_n1, psi_n2) \
+ kfe_n1**2 / k0**4 * scalarprod(ue_n1, uhdot_n2) * scalarprod(psisueps_n1, phidot_n2)
return (Sx, Sy)
def overlap(self, mode):
Sx, Sy = self.__overlap(mode)
return Sx - Sy
def norm(self):
return scipy.sqrt(self.overlap(self))
def normalize(self):
n = self.norm()
for ue, uh in zip(self.modie, self.modih):
ue.sl /= n
ue.al /= n
ue.sr /= n
ue.ar /= n
uh.sl /= n
uh.al /= n
uh.sr /= n
uh.ar /= n
def get_fields_for_FDTD(self, x, y):
"""Get mode's field on a staggered grid.
Note: ignores some fields on the boudaries.
"""
x0 = self.get_x()
y0 = self.get_y()
Ex, Ey, Ez, cBx, cBy, cBz = self.fields(x0, y0)
# Ex: ignores y = 0, max
x_Ex_FDTD = EMpy.utils.centered1d(x)
y_Ex_FDTD = y[1:-1]
Ex_FDTD = EMpy.utils.interp2(x_Ex_FDTD, y_Ex_FDTD, x0, y0, Ex)
# Ey: ignores x = 0, max
x_Ey_FDTD = x[1:-1]
y_Ey_FDTD = EMpy.utils.centered1d(y)
Ey_FDTD = EMpy.utils.interp2(x_Ey_FDTD, y_Ey_FDTD, x0, y0, Ey)
# Ez: ignores x, y = 0, max
x_Ez_FDTD = x[1:-1]
y_Ez_FDTD = y[1:-1]
Ez_FDTD = EMpy.utils.interp2(x_Ez_FDTD, y_Ez_FDTD, x0, y0, Ez)
# Hx: ignores x = 0, max, /120pi, reverse direction
x_Hx_FDTD = x[1:-1]
y_Hx_FDTD = EMpy.utils.centered1d(y)
Hx_FDTD = EMpy.utils.interp2(x_Hx_FDTD, y_Hx_FDTD, x0, y0, cBx) / (-120. * numpy.pi) # OKKIO!
# Hy: ignores y = 0, max, /120pi, reverse direction
x_Hy_FDTD = EMpy.utils.centered1d(x)
y_Hy_FDTD = y[1:-1]
Hy_FDTD = EMpy.utils.interp2(x_Hy_FDTD, y_Hy_FDTD, x0, y0, Hy) / (-120. * numpy.pi)
# Hz: /120pi, reverse direction
x_Hz_FDTD = EMpy.utils.centered1d(x)
y_Hz_FDTD = EMpy.utils.centered1d(y)
Hz_FDTD = EMpy.utils.interp2(x_Hz_FDTD, y_Hz_FDTD, x0, y0, Hz) / (-120. * numpy.pi)
return (Ex_FDTD, Ey_FDTD, Ez_FDTD, Hx_FDTD, Hy_FDTD, Hz_FDTD)
def plot(self, x_=None, y_=None):
if x_ is None:
x = self.get_x()
else:
x = numpy.atleast_1d(x_)
if y_ is None:
y = self.get_y()
else:
y = numpy.atleast_1d(y_)
f = self.fields(x, y)
# fields
pylab.figure()
titles = ['Ex', 'Ey', 'Ez', 'cBx', 'cBy', 'cBz']
for i in range(6):
subplot_id = 231 + i
pylab.subplot(subplot_id)
pylab.contour(x, y, numpy.abs(f[i]))
pylab.xlabel('x')
pylab.ylabel('y')
pylab.title(titles[i])
pylab.axis('image')
pylab.show()
# power
pylab.figure()
pylab.contour(x, y, numpy.abs(f[-1]))
pylab.xlabel('x')
pylab.ylabel('y')
pylab.title('cSz')
pylab.axis('image')
pylab.show()
def __str__(self):
return 'neff = %s' % (self.keff / (2 * numpy.pi / self.slicesx[0].wl))
class FMM(ModeSolver):
pass
class FMM1d(FMM):
"""Drive to simulate 1d structures.
Examples
========
Find the first 3 TE modes of two slabs of refractive indeces 1 and 3,
of thickness 1um each, for wl = 1, with symmetric boundary conditions:
>>> import numpy
>>> import FMM
>>> Uy = numpy.array([0., 1., 2.])
>>> ny = numpy.array([1., 3.])
>>> wl = 1.
>>> nmodi = 3
>>> simul = FMM.FMM1d(Uy, ny, 'SS').solve(wl, nmodi, 'TE')
>>> keff_0_expected = 18.790809413149393
>>> keff_1_expected = 18.314611633384185
>>> keff_2_expected = 17.326387847565034
>>> assert(numpy.allclose(simul.modes[0].keff, keff_0_expected))
>>> assert(numpy.allclose(simul.modes[1].keff, keff_1_expected))
>>> assert(numpy.allclose(simul.modes[2].keff, keff_2_expected))
"""
def __init__(self, Uy, ny, boundary):
"""Set coordinates of regions, refractive indeces and boundary conditions."""
self.Uy = Uy
self.ny = ny
self.boundary = boundary
def solve(self, wl, nmodes, polarization, verbosity=0):
"""Find nmodes modes at a given wavelength and polarization."""
Message('Solving 1d modes.', 1).show(verbosity)
self.wl = wl
self.nmodes = nmodes
self.polarization = polarization
self.modes = FMM1d_y(self.Uy, self.ny, self.wl, self.nmodes, self.boundary, self.polarization, verbosity)
return self
class FMM2d(FMM):
"""Drive to simulate 2d structures.
Examples
========
Find the first 2 modes of a lossy Si channel waveguide in SiO2, using
only 3 1dmodes and with electric and magnetic bc on x and y, respectively:
>>> import numpy
>>> import FMM
>>> wl = 1.55
>>> nmodislices = 3
>>> nmodi2d = 2
>>> Ux = numpy.array([0, 2, 2.4, 4.4])
>>> Uy = numpy.array([0, 2, 2.22, 4.22])
>>> boundary = Boundary(xleft='Electric Wall',
yleft='Magnetic Wall',
xright='Electric Wall',
yright='Magnetic Wall')
>>> n2 = 1.446
>>> n1 = 3.4757 - 1e-4j
>>> refindex = numpy.array([[n2, n2, n2],
[n2, n1, n2],
[n2, n2, n2]])
>>> simul = FMM.FMM2d(Ux, Uy, refindex, boundary).solve(wl, nmodislices, nmodi2d)
>>> keff0_expected = 9.666663697969399e+000 -4.028846755836984e-004j
>>> keff1_expected = 7.210476803133368e+000 -2.605078086535284e-004j
>>> assert(numpy.allclose(simul.modes[0].keff, keff0_expected))
>>> assert(numpy.allclose(simul.modes[1].keff, keff1_expected))
"""
def __init__(self, Ux, Uy, rix, boundary):
"""Set coordinates of regions, refractive indeces and boundary conditions."""
self.Ux = Ux
self.Uy = Uy
self.rix = rix
self.boundary = boundary
def solve(self, wl, n1dmodes, nmodes, verbosity=0):
"""Find nmodes modes at a given wavelength using n1dmodes 1d modes in each slice."""
Message('Solving 2d modes', 1).show(verbosity)
self.wl = wl
self.n1dmodes = n1dmodes
self.nmodes = nmodes
self.slices = script1d(self.Ux, self.Uy, self.rix, self.wl, self.boundary, self.n1dmodes, verbosity)
self.modes = FMM1d_x_component(self.slices, nmodes, verbosity)
return self
def analyticalsolution(nmodi, TETM, FMMpars):
betay = FMMpars['beta']
epsilon = FMMpars['epsilon']
Uy = FMMpars['Uy']
by = FMMpars['boundary']
Nregions = len(epsilon)
sl = numpy.zeros((nmodi,Nregions), dtype=complex)
sr = numpy.zeros_like(sl)
al = numpy.zeros_like(sl)
ar = numpy.zeros_like(sl)
# interval
D = Uy[-1] - Uy[0]
if TETM == 'TE':
N = numpy.sqrt(2. / D)
else:
N = numpy.sqrt(2. / D * epsilon[0])
# boundary condition
if by == 'AA':
kn = (numpy.pi * numpy.arange(1, nmodi + 1) / D)
kn = kn[:, numpy.newaxis]
sl = numpy.sin(kn * (Uy[:-1] - Uy[0]))
sr = numpy.sin(kn * (Uy[1:] - Uy[0]))
al = numpy.cos(kn * (Uy[:-1] - Uy[0]))
ar = numpy.cos(kn * (Uy[1:] - Uy[0]))
sr[:, -1] = 0.
sl[:, 0] = 0.
elif by == 'AS':
kn = (numpy.pi * (numpy.arange(0, nmodi) + .5) / D)
kn = kn[:, numpy.newaxis]
sl = numpy.sin(kn * (Uy[:-1] - Uy[0]))
sr = numpy.sin(kn * (Uy[1:] - Uy[0]))
al = numpy.cos(kn * (Uy[:-1] - Uy[0]))
ar = numpy.cos(kn * (Uy[1:] - Uy[0]))
ar[:, -1] = 0.
sl[:, 0] = 0.
elif by == 'SA':
kn = (numpy.pi * ( | numpy.arange(0, nmodi) | numpy.arange |
from warnings import warn
import numpy as np
import pandas as pd
import scipy.stats as stats
from scipy import linalg
from ..doctools import document
from ..exceptions import PlotnineWarning
from .stat import stat
@document
class stat_ellipse(stat):
"""
Calculate normal confidence interval ellipse
{usage}
Parameters
----------
{common_parameters}
type : str in ['t', 'norm', 'euclid'] (default: 't')
The type of ellipse.
- ``'t'`` - assumes a multivariate t-distribution, and
- ``'norm'`` - assumes a multivariate normal distribution.
- ``'euclid'`` - draws a circle with the radius equal to
`level`, representing the euclidean distance from the
center.
level : float, optional (default: 0.95)
The confidence level at which to draw the ellipse.
segments : int, optional (default: 51)
Number of segments to be used in drawing the ellipse.
"""
REQUIRED_AES = {'x', 'y'}
DEFAULT_PARAMS = {'geom': 'path', 'position': 'identity',
'na_rm': False, 'type': 't', 'level': 0.95,
'segments': 51}
@classmethod
def compute_group(cls, data, scales, **params):
level = params['level']
segments = params['segments']
type_ = params['type']
dfn = 2
dfd = len(data) - 1
if dfd < 3:
warn("Too few points to calculate an ellipse", PlotnineWarning)
return pd.DataFrame({'x': [], 'y': []})
m = np.asarray(data[['x', 'y']])
# The stats used to create the ellipse
if type_ == 't':
res = cov_trob(m)
cov = res['cov']
center = res['center']
elif type_ == 'norm':
cov = np.cov(m, rowvar=False)
center = np.mean(m, axis=0)
elif type_ == 'euclid':
cov = np.cov(m, rowvar=False)
cov = np.diag(np.repeat(np.diag(cov).min(), 2))
center = np.mean(m, axis=0)
# numpy's cholesky function does not gaurantee upper/lower
# triangular factorization.
chol_decomp = linalg.cholesky(cov, lower=False)
# Parameters of the ellipse
if type_ == 'euclid':
radius = level / chol_decomp.max()
else:
radius = np.sqrt(dfn * stats.f.ppf(level, dfn, dfd))
space = np.linspace(0, 2*np.pi, segments)
# Catesian coordinates
unit_circle = np.column_stack([np.cos(space), np.sin(space)])
res = center + radius * np.dot(unit_circle, chol_decomp)
return pd.DataFrame({'x': res[:, 0], 'y': res[:, 1]})
def cov_trob(x, wt=None, cor=False, center=True, nu=5, maxit=25,
tol=0.01):
"""
Covariance Estimation for Multivariate t Distribution
Estimates a covariance or correlation matrix assuming the
data came from a multivariate t distribution: this provides
some degree of robustness to outlier without giving a high
breakdown point.
**credit**: This function a port of the R function
``MASS::cov.trob``.
Parameters
----------
x : array
data matrix. Missing values (NaNs) are not allowed.
wt : array
A vector of weights for each case: these are treated as
if the case i actually occurred ``wt[i]`` times.
cor : bool
Flag to choose between returning the correlation
(``cor=True``) or covariance (``cor=False``) matrix.
center : array or bool
A logical value or a numeric vector providing the location
about which the covariance is to be taken.
If ``center=False``, no centering is done; if
``center=True`` the MLE of the location vector is used.
nu : int
'degrees of freedom' for the multivariate t distribution.
Must exceed 2 (so that the covariance matrix is finite).
maxit : int
Maximum number of iterations in fitting.
tol : float
Convergence tolerance for fitting.
Returns
-------
out : dict
A dictionary with with the following key-value
- ``cov`` : the fitted covariance matrix.
- ``center`` : the estimated or specified location vector.
- ``wt`` : the specified weights: only returned if the
wt argument was given.
- ``n_obs`` : the number of cases used in the fitting.
- ``cor`` : the fitted correlation matrix: only returned
if ``cor=True``.
- ``call`` : The matched call.
- ``iter`` : The number of iterations used.
References
----------
- <NAME>, <NAME> and <NAME> (1994) A curious likelihood
identity for the multivariate t-distribution. *Communications in
Statistics-Simulation and Computation* **23**, 441-453.
- <NAME>. and <NAME>. (1999) *Modern Applied
Statistics with S-PLUS*. Third Edition. Springer.
"""
def test_values(x):
if pd.isnull(x).any() or np.isinf(x).any():
raise ValueError("Missing or infinite values in 'x'")
def scale_simp(x, center, n, p):
return x - np.repeat([center], n, axis=0)
x = np.asarray(x)
n, p = x.shape
test_values(x)
# wt
miss_wt = wt is None
if not miss_wt:
wt = np.asarray(wt)
wt0 = wt
if len(wt) != n:
raise ValueError(
"length of 'wt' must equal number of observations.")
if any(wt < 0):
raise ValueError("Negative weights not allowed.")
if not np.sum(wt):
raise ValueError("No positive weights.")
x = x[wt > 0, :]
wt = wt[wt > 0]
n, _ = x.shape
else:
wt = np.ones(n)
wt = wt[:, np.newaxis]
# loc
loc = np.sum(wt*x, axis=0) / wt.sum()
try:
_len = len(center)
except TypeError:
if isinstance(center, bool) and not center:
loc = np.zeros(p)
else:
if _len != p:
raise ValueError("'center' is not the right length")
loc = p
use_loc = isinstance(center, bool) and center
w = wt * (1 + p/nu)
for iteration in range(maxit):
w0 = w
X = scale_simp(x, loc, n, p)
_, s, v = linalg.svd(np.sqrt(w/np.sum(w)) * X)
# wX = X @ v.T @ np.diag(np.full(p, 1/s))
wX = np.dot(np.dot(X, v.T), np.diag(np.full(p, 1/s)))
# Q = np.squeeze((wX**2) @ np.ones(p))
Q = np.squeeze(np.dot(wX**2, np.ones(p)))
w = (wt * (nu + p)) / (nu + Q)[:, np.newaxis]
if use_loc:
loc = np.sum(w*x, axis=0) / w.sum()
if all( | np.abs(w-w0) | numpy.abs |
#!/usr/bin/python
# -*- coding: utf-8 -*-
from ddf_library.context import COMPSsContext
import pandas as pd
import numpy as np
def binarizer(cc):
print("\n_____Testing Binarizer_____\n")
columns = ['x', 'y', 'z']
df = pd.DataFrame([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]],
columns=columns)
ddf = cc.parallelize(df, 4)
from ddf_library.functions.ml.feature import Binarizer
res = Binarizer(threshold=0)\
.transform(ddf, output_col=columns,
input_col=columns, remove=True).to_df().values.tolist()
sol = [[1., 0., 1.], [1., 0., 0.], [0., 1., 0.]]
if not np.allclose(res, sol):
raise Exception(" Output different from expected.")
print("Ok")
def maxabs_scaler(cc):
print("_____Testing MaxAbsScaler _____")
cols = ['x', 'y', 'z']
df_maxabs = pd.DataFrame([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]],
columns=cols)
# Creating DDF from DataFrame
ddf_maxabs = cc.parallelize(df_maxabs, 4)
from ddf_library.functions.ml.feature import MaxAbsScaler
ddf_maxabs = MaxAbsScaler() \
.fit_transform(ddf_maxabs, input_col=cols)
res = ddf_maxabs.to_df(cols).values.tolist()
sol = [[0.5, -1., 1], [1., 0., 0.], [0., 1., -0.5]]
if not np.allclose(res, sol):
raise Exception(" Output different from expected.")
print("Ok")
def minmax_scaler(cc):
print("_____Testing MinMaxScaler _____")
cols = ['x', 'y']
df_minmax = pd.DataFrame([[-1, 2], [-0.5, 6], [0, 10], [1, 18]],
columns=cols)
ddf_minmax = cc.parallelize(df_minmax, 4)
from ddf_library.functions.ml.feature import MinMaxScaler
ddf_minmax = MinMaxScaler()\
.fit_transform(ddf_minmax, input_col=cols)
res = ddf_minmax.to_df(cols).values.tolist()
sol = [[0., 0.], [0.25, 0.25], [0.5, 0.5], [1., 1.]]
if not np.allclose(res, sol):
raise Exception(" Output different from expected.")
print("Ok")
def std_scaler(cc):
print("_____Testing StandardScaler _____")
cols = ['x', 'y']
df_std = pd.DataFrame([[0, 0], [0, 0], [1, 1], [1, 1]],
columns=cols)
ddf_std = cc.parallelize(df_std, 4)
from ddf_library.functions.ml.feature import StandardScaler
scaler = StandardScaler(with_mean=True,
with_std=True).fit(ddf_std, input_col=cols)
ddf_std = scaler.transform(ddf_std)
res = ddf_std.to_df(cols).values.tolist()
sol = [[-1., -1.], [-1., -1.], [1., 1.], [1., 1.]]
if not np.allclose(res, sol):
raise Exception(" Output different from expected.")
print("Ok")
def pca_workflow(cc):
print("\n_____Testing PCA_____\n")
df = pd.read_csv('./datasets/iris-dataset.csv', sep=',')
df.dropna(how="all", inplace=True)
columns = df.columns.tolist()
columns.remove('class')
ddf = cc.parallelize(df, 4)
from ddf_library.functions.ml.feature import StandardScaler
ddf_std = StandardScaler().fit_transform(ddf, input_col=columns)
n_components = 2
new_columns = ['col{}'.format(i) for i in range(n_components)]
from ddf_library.functions.ml.feature import PCA
pca = PCA(n_components=n_components)
res = pca.fit_transform(ddf_std, input_col=columns, output_col=new_columns)\
.to_df(new_columns).values.tolist()[0:10]
sol = [[-2.26454173, -0.505703903],
[-2.08642550, 0.655404729],
[-2.36795045, 0.318477311],
[-2.30419716, 0.575367713],
[-2.38877749, -0.674767397],
[-2.07053681, -1.51854856],
[-2.44571134, -0.0745626750],
[-2.23384186, -0.247613932],
[-2.34195768, 1.09514636],
[-2.18867576, 0.448629048]]
sol_values = [2.93035378, 0.92740362, 0.14834223, 0.02074601]
cond1 = np.allclose(res, sol)
cond2 = | np.allclose(pca.model['eig_values'], sol_values) | numpy.allclose |
"""
Bayesian Mixture Model.
Copyright (C) 2017, <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
from scipy.special import logsumexp
from .model import EFDStats, DiscreteLatentModel
from ..densities import Dirichlet, NormalGamma, NormalDiag
class Mixture(DiscreteLatentModel):
"""Bayesian Mixture Model.
Bayesian Mixture Model with a Dirichlet prior over the weights.
"""
def create(n_comp, mean, var):
"""Create and initialize a Bayesian Mixture Model.
Parameters
----------
n_comp : int
Number of components in the mixture.
mean : numpy.ndarray
Mean of the data set to train on.
var : numpy.ndarray
Variance of the data set to train on.
Returns
-------
model : :class:`Mixture`
A new mixture model.
"""
priors = []
prior_mean = mean.copy()
prior_var = var.copy()
for i in range(n_comp):
prior = NormalGamma(
prior_mean,
np.ones_like(mean),
np.ones_like(var),
prior_var,
)
priors.append(prior)
dirichlet_prior = Dirichlet(np.ones(n_comp))
dirichlet_posterior = Dirichlet(np.ones(n_comp))
components = []
cov = np.diag(prior_var)
for i in range(n_comp):
s_mean = | np.random.multivariate_normal(mean, cov) | numpy.random.multivariate_normal |
import numpy as np
def randomizePostions(postions,cell,random_seed=None):
if random_seed is not None: np.random.seed(random_seed)
for i in range(postions.shape[0]):
postions[i][0] = np.random.uniform(0,cell[0])
postions[i][1] = np.random.uniform(0,cell[1])
postions[i][2] = np.random.uniform(0,cell[2])
#-------------------------------
def randomDisplacement(postions,max_displacement,particle_index,random_seed=None):
indexes = [particle_index]
if random_seed is not None: np.random.seed(random_seed)
for k in indexes:
postions[k][0] += max_displacement * np.random.uniform(-1,1)
postions[k][1] += max_displacement * np.random.uniform(-1,1)
postions[k][2] += max_displacement * np.random.uniform(-1,1)
#-------------------------------
def writePostionsToFileXYZ(filename,postions,particle_names,cell=None,append=True):
num_particles = postions.shape[0]
if len(particle_names)==1: particle_names = particle_names*num_particles
if append:
f = open(filename,'a')
else:
f = open(filename,'w')
f.write(" {0}\n\n".format(num_particles))
for i in range(num_particles):
a = particle_names[i]
p = postions[i]
if cell is not None: p = p - np.floor(p/cell) * cell
out_str = " {0} {1:20.9f} {2:20.9f} {3:20.9f}\n".format(a,p[0],p[1],p[2])
f.write(out_str)
f.close()
#-------------------------------
def writePostionsToFileGro(filename,postions,particle_names,header,cell=None,append=True):
num_particles = postions.shape[0]
if len(particle_names)==1: particle_names = particle_names*num_particles
if append:
f = open(filename,'a')
else:
f = open(filename,'w')
f.write(" {0}\n".format(header))
f.write(" {0}\n".format(num_particles))
for i in range(num_particles):
rstr = "SOL"
a = particle_names[i]
p = postions[i]
if cell is not None: p = p - np.floor(p/cell) * cell
out_str = "{0:5d}{1:5s}{2:5s}{3:5d}{4:8.3f}{5:8.3f}{6:8.3f}\n".format(i,rstr,a,i,p[0],p[1],p[2])
f.write(out_str)
if cell is not None:
out_str = "{0:10.5f}{1:10.5f}{2:10.5f}\n".format(cell[0],cell[1],cell[2])
f.write(out_str)
f.close()
#-------------------------------
def readPostionsFromFileGro(filename):
f = open(filename,'r')
rawdata = f.readlines()
f.close()
#
num_particles = int(rawdata[1])
#
cell_str = rawdata[-1]
cell = []
cell.append(float(cell_str[0:10]))
cell.append(float(cell_str[10:20]))
cell.append(float(cell_str[20:30]))
cell = | np.array(cell) | numpy.array |
import os
import copy
from tqdm import tqdm
import numpy as np
import pandas as pd
import plotly.graph_objects as go
from stl import mesh
from typing import Dict, List, Optional
from .settings_pyskindose import PhantomDimensions
from pyskindose.plotting.create_ploty_ijk_indices import \
_create_plotly_ijk_indices_for_cuboid_objects
# valid phantom types
VALID_PHANTOM_MODELS = ["plane", "cylinder", "human", "table", "pad"]
class Phantom:
"""Create and handle phantoms for patient, support table and pad.
This class creates a phatom of any of the types specified in
VALID_PHANTOM_MODELS (plane, cylinder or human to represent the patient,
as well as patient support table and pad). The patient phantoms consists of
a number of skin cells where the skin dose can be calculated.
Attributes
----------
phantom_model : str
Type of phantom, i.e. "plane", "cylinder", "human", "table" or "pad"
r : np.array
n*3 array where n are the number of phantom skin cells. Each row
contains the xyz coordinate of one of the phantom skin cells
ijk : np.array
A matrix containing vertex indices. This is required in order to
plot the phantom using plotly Mesh3D. For more info, see "i", "j", and
"k" at https://plot.ly/python/reference/#mesh3d
dose : np.array
An empty 1d array to store skin dose calculation for each of the n
phantom cells. Only for patient phantom types (plane, cylinder, human)
n : np.array
normal vectors to each of the n phantom skin cells. (only for 3D
patient phantoms, i.e. "cylinder" and "human")
r_ref : np.array
Empty array to store of reference position of the phantom cells after
the phantom has been aligned in the geometry with the
position_patient_phantom_on_table function in geom_calc.py
table_length : float
length of patient support table. The is needed for all phantom object
to select correct rotation origin for At1, At2, and At3.
Methods
-------
rotate(rotation)
Rotating the phantom about any of the x, y, or z axis
translate(dr)
Translates the phantom along the x, y or z direction
save_position
Saves the reference position after the phantom has been properly
positioned in the irradiation geometry. This method is called in the
position_patient_phantom_on_table function
position(data_norm)
Positions the phantom from reference position to actual position
according to the table displacement info in data_norm
"""
def __init__(self,
phantom_model: str, phantom_dim: PhantomDimensions,
human_mesh: Optional[str] = None):
"""Create the phantom of choice.
Parameters
----------
phantom_model : str
Type of phantom to create. Valid selections are 'plane',
'cylinder', 'human', "table" an "pad".
phantom_dim : PhantomDimensions
instance of class PhantomDimensions containing dimensions for
all phantoms models except human phantoms: Length, width, radius,
thickness etc.
human_mesh : str, optional
Choose which human mesh phantom to use. Valid selection are names
of the *.stl-files in the phantom_data folder (The default is none.
Raises
------
ValueError
Raises value error if unsupported phantom type are selected,
or if phantom_model='human' selected, without specifying
human_mesh
"""
self.phantom_model = phantom_model.lower()
# Raise error if invalid phantom model selected
if self.phantom_model not in VALID_PHANTOM_MODELS:
raise ValueError(f"Unknown phantom model selected. Valid type:"
f"{'.'.join(VALID_PHANTOM_MODELS)}")
self.r_ref: np.array
# Save table length for all phantom in order to choose correct rotation
# origin when applying At1, At2, and At3
self.table_length = phantom_dim.table_length
# creates a plane phantom (2D grid)
if phantom_model == "plane":
# Use a dense grid if specified by user
if phantom_dim.plane_resolution.lower() == 'dense':
res_length = res_width = 2.0
elif phantom_dim.plane_resolution.lower() == 'sparse':
res_length = res_width = 1.0
# Linearly spaced points along the longitudinal direction
x = np.linspace(-phantom_dim.plane_width / 2,
+phantom_dim.plane_width / 2,
int(res_width * phantom_dim.plane_width + 1))
# Linearly spaced points along the lateral direction
z = np.linspace(0, -phantom_dim.plane_length,
int(res_length * phantom_dim.plane_length))
# Create phantom in form of rectangular grid
x_plane, z_plane = np.meshgrid(x, z)
t = phantom_dim.plane_width
# Create index vectors for plotly mesh3d plotting
i2: List[int] = []
i1 = j1 = k1 = i2
for i in range(len(x) - 1):
for j in range(len(z) - 1):
i1 = i1 + [j * len(x) + i]
j1 = j1 + [j * len(x) + i + 1]
k1 = k1 + [j * len(x) + i + len(x)]
i2 = i2 + [j * len(x) + i + len(x) + 1]
self.r = np.column_stack((x_plane.ravel(),
np.zeros(len(x_plane.ravel())),
z_plane.ravel()))
self.ijk = np.column_stack((i1 + i2, j1 + k1, k1 + j1))
self.dose = np.zeros(len(self.r))
# creates a cylinder phantom (elliptic)
elif phantom_model == "cylinder":
# Use a dense grid if specified by user
if phantom_dim.cylinder_resolution.lower() == 'dense':
res_length = 4
res_width = 0.05
elif phantom_dim.cylinder_resolution.lower() == 'sparse':
res_length = 1.0
res_width = 0.1
# Creates linearly spaced points along an ellipse
# in the lateral direction
t = np.arange(0 * np.pi, 2 * np.pi, res_width)
x = (phantom_dim.cylinder_radii_a * np.cos(t)).tolist()
y = (phantom_dim.cylinder_radii_b * np.sin(t)).tolist()
# calculate normal vectors of a cylinder (pointing outwards)
nx = np.cos(t) / (
np.sqrt(np.square(np.cos(t) + 4 * np.square( | np.sin(t) | numpy.sin |
from __future__ import print_function
import gc, os, sys
import numpy as np
import scipy as sp
import numpy.linalg as la
import scipy.linalg as sla
from numpy.linalg import norm
from time import time
from copy import deepcopy
from warnings import warn
from time import time
from Kuru.FiniteElements.Assembly import Assemble #, AssembleExplicit
from Kuru.FiniteElements.LocalAssembly.KinematicMeasures import *
from Kuru.FiniteElements.LocalAssembly._KinematicMeasures_ import _KinematicMeasures_
from Kuru import Mesh
from Kuru import FunctionSpace, QuadratureRule
__all__ = ["GrowthRemodelingIntegrator"]
class GrowthRemodelingIntegrator(object):
"""Base class for structural time integerators
"""
def __init__(self,
gain,
turnover,
density_turnover="self",
not_degradation=True,
degradation_at_line=False,
degradation_at_point=False,
degradation_point=None,
aging_only=False,
monitoring_node=0,
damage_spread_space=None,
damage_spread_time=None,
damage_axis=0,
has_dissection=False,
dissection_time_threshold = None,
maximum_dissection_spread = None,
dissection_pressure = None
):
self.HomeostaticStress = None
self.gain = gain
self.turnover = turnover
self.density_turnover = density_turnover
self.degradation_at_line = degradation_at_line
self.degradation_at_point = degradation_at_point
self.degradation_point = degradation_point
self.aging_only = aging_only
self.not_degradation = not_degradation
self.monitoring_node = monitoring_node
if degradation_at_point or aging_only or degradation_at_line:
self.not_degradation = False
if degradation_point is None and degradation_at_point:
self.degradation_point = [0.,0.,0.]
self.damage_spread_space = damage_spread_space
self.damage_spread_time = damage_spread_time
self.damage_axis = damage_axis
self.has_dissection = has_dissection
self.dissection_time_threshold = dissection_time_threshold
self.maximum_dissection_spread = maximum_dissection_spread
self.dissection_pressure = dissection_pressure
def HomeostaticDistortion(self, fem_solver, formulation, TotalDisp, Increment):
""" check the distortion of homeostasis"""
dmesh = Mesh()
dmesh.points = TotalDisp[:,:formulation.ndim,Increment]
dmesh_bounds = dmesh.Bounds
distortion = 100.0*np.sqrt(dmesh_bounds[1,0]**2+dmesh_bounds[1,1]**2+\
dmesh_bounds[1,2]**2)/0.010
if distortion<5.0:
print("The Distortion in Homeostasis is: {}".format(distortion))
else:
print("The Distortion in Homeostasis is: {}".format(distortion))
sys.exit("Growth and Remodeling solver stop, distortion in Homeostasis is to big")
def LogSave(self, fem_solver, formulation, TotalDisp, Increment, materials, FibreStress, gr_materials):
if fem_solver.print_incremental_log:
# find the set of the node under surveillance
imat = -1
for i in range(gr_materials.shape[0]):
if self.monitoring_node in materials[gr_materials[i]].node_set:
imat = gr_materials[i]
imat0 = i
inode = np.where(materials[imat].node_set==self.monitoring_node)[0][0]
break
if imat is -1:
print("Set of the node is not recognized. I will use material 0 and its node 0.")
imat = gr_materials[0]
imat0 = 0
inode = 0
dmesh = Mesh()
dmesh.points = TotalDisp[:,:formulation.ndim,Increment]
dmesh_bounds = dmesh.Bounds
print("\nMinimum and maximum incremental solution values at increment {} are \n".\
format(Increment),dmesh_bounds)
print("\nGrowth and Remodeling properties at node, {}".format(self.monitoring_node))
print("Densities: {:8.3f}, {:8.3f}, {:8.3f}, {:8.3f}, {:8.3f}, {:8.3f}".\
format(materials[imat].state_variables[inode,14],materials[imat].state_variables[inode,15],\
materials[imat].state_variables[inode,16],materials[imat].state_variables[inode,17],\
materials[imat].state_variables[inode,18],materials[imat].state_variables[inode,19]))
print("Remodeling: {:6.3f}, {:6.3f}, {:6.3f}, {:6.3f}, {:6.3f}".\
format(materials[imat].state_variables[inode,9],materials[imat].state_variables[inode,10],\
materials[imat].state_variables[inode,11],materials[imat].state_variables[inode,12],\
materials[imat].state_variables[inode,13]))
print("Growth: {:6.3f}".format(materials[imat].state_variables[inode,20]))
print("FibreStress: {:8.3f}, {:8.3f}, {:8.3f}, {:8.3f}, {:8.3f}".\
format(FibreStress[imat0][inode,0],FibreStress[imat0][inode,1],FibreStress[imat0][inode,2],\
FibreStress[imat0][inode,3],FibreStress[imat0][inode,4]))
# SAVE INCREMENTAL SOLUTION IF ASKED FOR
if fem_solver.save_incremental_solution:
# FOR BIG MESHES
if Increment % fem_solver.incremental_solution_save_frequency !=0:
return
from scipy.io import savemat
filename = fem_solver.incremental_solution_filename
if filename is not None:
if ".mat" in filename:
filename = filename.split(".")[0]
savemat(filename+"_"+str(Increment),
{'solution':TotalDisp[:,:,Increment]},do_compression=True)
else:
raise ValueError("No file name provided to save incremental solution")
def NewtonRaphson(self, function_spaces, formulation, solver, Increment, K, NodalForces,
Residual, mesh, Eulerx, materials, boundary_condition, AppliedDirichletInc, fem_solver):
Tolerance = fem_solver.newton_raphson_tolerance
LoadIncrement = fem_solver.number_of_load_increments
Iter = 0
fem_solver.iterative_norm_history = []
# APPLY INCREMENTAL DIRICHLET PER LOAD STEP (THIS IS INCREMENTAL NOT ACCUMULATIVE)
IncDirichlet = boundary_condition.UpdateFixDoFs(AppliedDirichletInc,
K.shape[0],formulation.nvar)
# UPDATE EULERIAN COORDINATE
Eulerx += IncDirichlet[:,:formulation.ndim]
while fem_solver.norm_residual > Tolerance or Iter==0:
# GET THE REDUCED SYSTEM OF EQUATIONS
K_b, F_b = boundary_condition.GetReducedMatrices(K,Residual)[:2]
# SOLVE THE SYSTEM
sol = solver.Solve(K_b,-F_b)
# GET ITERATIVE SOLUTION
dU = boundary_condition.UpdateFreeDoFs(sol,K.shape[0],formulation.nvar)
# UPDATE THE EULERIAN COMPONENTS
# UPDATE THE GEOMETRY
Eulerx += dU[:,:formulation.ndim]
# RE-ASSEMBLE - COMPUTE STIFFNESS AND INTERNAL TRACTION FORCES
K, TractionForces = Assemble(fem_solver, function_spaces, formulation, mesh, materials,
boundary_condition, Eulerx)[:2]
# COMPUTE ROBIN STIFFNESS AND FORCES (EXTERNAL)
K, TractionForces = boundary_condition.ComputeRobinForces(mesh, materials, function_spaces,
fem_solver, Eulerx, K, TractionForces)
# FIND THE RESIDUAL
Residual[boundary_condition.columns_in] = TractionForces[boundary_condition.columns_in] - \
NodalForces[boundary_condition.columns_in]
# SAVE THE NORM
fem_solver.abs_norm_residual = la.norm(Residual[boundary_condition.columns_in])
if Iter==0:
fem_solver.NormForces = la.norm(Residual[boundary_condition.columns_in])
fem_solver.norm_residual = np.abs(la.norm(Residual[boundary_condition.columns_in])/fem_solver.NormForces)
# SAVE THE NORM
fem_solver.NRConvergence['Increment_'+str(Increment)] = np.append(fem_solver.NRConvergence[\
'Increment_'+str(Increment)],fem_solver.norm_residual)
print("Iteration {} for increment {}.".format(Iter, Increment) +\
" Residual (abs) {0:>16.7g}".format(fem_solver.abs_norm_residual),
"\t Residual (rel) {0:>16.7g}".format(fem_solver.norm_residual))
# BREAK BASED ON RELATIVE NORM
if np.abs(fem_solver.abs_norm_residual) < Tolerance:
break
# BREAK BASED ON INCREMENTAL SOLUTION - KEEP IT AFTER UPDATE
if norm(dU) <= fem_solver.newton_raphson_solution_tolerance and Iter!=0:
print("Incremental solution within tolerance i.e. norm(dU): {}".format(norm(dU)))
break
# UPDATE ITERATION NUMBER
Iter +=1
if Iter==fem_solver.maximum_iteration_for_newton_raphson:
fem_solver.newton_raphson_failed_to_converge = True
break
if np.isnan(fem_solver.norm_residual) or fem_solver.norm_residual>1e06:
fem_solver.newton_raphson_failed_to_converge = True
break
# IF BREAK WHEN NEWTON RAPHSON STAGNATES IS ACTIVATED
if fem_solver.break_at_stagnation:
fem_solver.iterative_norm_history.append(fem_solver.norm_residual)
if Iter >= 5:
if np.mean(fem_solver.iterative_norm_history) < 1.:
break
# USER DEFINED CRITERIA TO BREAK OUT OF NEWTON-RAPHSON
if fem_solver.user_defined_break_func != None:
if fem_solver.user_defined_break_func(Increment,Iter,fem_solver.norm_residual,fem_solver.abs_norm_residual, Tolerance):
break
# USER DEFINED CRITERIA TO STOP NEWTON-RAPHSON AND THE WHOLE ANALYSIS
if fem_solver.user_defined_stop_func != None:
if fem_solver.user_defined_stop_func(Increment,Iter,fem_solver.norm_residual,fem_solver.abs_norm_residual, Tolerance):
fem_solver.newton_raphson_failed_to_converge = True
break
return Eulerx, K, Residual
def GetFibreStressAndSoftness(self, mesh, formulation, material, fem_solver, Eulerx, average_derived_quantities=True):
"""
steps: [list,np.1darray] for which time steps/increments the data should
be recovered
"""
det = np.linalg.det
inv = np.linalg.inv
# GET THE UNDERLYING LINEAR MESH
# lmesh = mesh.GetLinearMesh()
C = mesh.InferPolynomialDegree() - 1
ndim = mesh.InferSpatialDimension()
nelem = mesh.elements.shape[0]; npoint = mesh.points.shape[0]
nodeperelem = mesh.elements.shape[1]
# GET QUADRATURE
norder = 2*C
if norder == 0:
norder=1
# quadrature = QuadratureRule(qtype="gauss", norder=norder, mesh_type=mesh.element_type, optimal=3)
# Domain = FunctionSpace(mesh, quadrature, p=C+1)
Domain = FunctionSpace(mesh, p=C+1, evaluate_at_nodes=True)
Jm = Domain.Jm
AllGauss = Domain.AllGauss
Bases = Domain.Bases
# requires_geometry_update = fem_solver.requires_geometry_update
requires_geometry_update = True # ALWAYS TRUE FOR THIS ROUTINE
F = np.zeros((material.element_set.shape[0],nodeperelem,ndim,ndim))
# DEFINE CONSTITUENT STRESSES FOR GROWTH-REMODELING PROBLEM
ElemFibreStress = np.zeros((material.element_set.shape[0],nodeperelem,5)) # 5-fibres
ElemSoftness = np.zeros((material.element_set.shape[0],nodeperelem,5)) # 5-fibres
FibreStress = np.zeros((material.node_set.shape[0],5))
Softness = np.zeros((material.node_set.shape[0],5))
# LOOP OVER ELEMENTS
for ielem in range(material.element_set.shape[0]):
elem = material.element_set[ielem]
# GET THE FIELDS AT THE ELEMENT LEVEL
LagrangeElemCoords = mesh.points[mesh.elements[elem,:],:]
EulerElemCoords = Eulerx[mesh.elements[elem,:],:]
# GROWTH-REMODELING VALUES FOR THIS ELEMENT
material.MappingStateVariables(mesh,Domain,elem)
if material.has_low_level_dispatcher:
# GET LOCAL KINEMATICS
SpatialGradient, F[ielem,:,:,:], detJ, dV = _KinematicMeasures_(Jm, AllGauss[:,0],
LagrangeElemCoords, EulerElemCoords, requires_geometry_update)
# PARAMETERS FOR INCOMPRESSIBILITY (MEAN DILATATION METHOD HU-WASHIZU)
if material.is_incompressible:
MaterialVolume = np.sum(dV)
if fem_solver.has_growth_remodeling:
dve = np.true_divide(detJ,material.StateVariables[:,20])
CurrentVolume = np.sum(dve)
else:
CurrentVolume = np.sum(detJ)
material.pressure = material.kappa*(CurrentVolume-MaterialVolume)/MaterialVolume
# COMPUTE FIBRE STRESS AND SOFTNESS
ElemFibreStress[ielem,:,:],ElemSoftness[ielem,:,:] = material._ConstituentMeasures_(F[ielem,:,:,:],elem)
else:
# GAUSS LOOP IN VECTORISED FORM
ParentGradientX = np.einsum('ijk,jl->kil', Jm, LagrangeElemCoords)
# MATERIAL GRADIENT TENSOR IN PHYSICAL ELEMENT [\nabla_0 (N)]
MaterialGradient = np.einsum('ijk,kli->ijl', inv(ParentGradientX), Jm)
# DEFORMATION GRADIENT TENSOR [\vec{x} \otimes \nabla_0 (N)]
F[ielem,:,:,:] = np.einsum('ij,kli->kjl', EulerElemCoords, MaterialGradient)
# COMPUTE REMAINING KINEMATIC MEASURES
StrainTensors = KinematicMeasures(F[ielem,:,:,:], fem_solver.analysis_nature)
# GEOMETRY UPDATE IS A MUST
# MAPPING TENSOR [\partial\vec{X}/ \partial\vec{\varepsilon} (ndim x ndim)]
ParentGradientx = np.einsum('ijk,jl->kil',Jm,EulerElemCoords)
# SPATIAL GRADIENT TENSOR IN PHYSICAL ELEMENT [\nabla (N)]
SpatialGradient = np.einsum('ijk,kli->ilj',inv(ParentGradientx),Jm)
# COMPUTE ONCE detJ (GOOD SPEEDUP COMPARED TO COMPUTING TWICE)
detJ = np.einsum('i,i,i->i',AllGauss[:,0],np.abs(det(ParentGradientX)),
np.abs(StrainTensors['J']))
# COMPUTE PARAMETERS FOR MEAN DILATATION METHOD, IT NEEDS TO BE BEFORE COMPUTE HESSIAN AND STRESS
if material.is_incompressible:
dV = np.einsum('i,i->i',AllGauss[:,0],np.abs(det(ParentGradientX)))
MaterialVolume = np.sum(dV)
if fem_solver.has_growth_remodeling:
dve = np.true_divide(detJ,material.StateVariables[:,20])
CurrentVolume = np.sum(dve)
else:
CurrentVolume = | np.sum(detJ) | numpy.sum |
#! /usr/bin/env python
import os
import pdb
import time
import yaml
import json
import random
import shutil
import argparse
import numpy as np
from collections import defaultdict
# torch
import torch
import torch.nn as nn
import torch.nn.functional as F
from utils import AverageMeter
from solvers import Solver
__all__ = ['BaselineSolver']
def euclidean_dist(x, y):
x = torch.from_numpy(x).cuda()
y = torch.from_numpy(y).cuda()
dist = torch.sum(x ** 2, 1).unsqueeze(1) + torch.sum(y ** 2, 1).unsqueeze(
1).transpose(0, 1) - 2 * torch.matmul(x, y.transpose(0, 1))
dist = torch.sqrt(F.relu(dist))
return dist
def cosine_dist(x, y):
x = torch.from_numpy(x).cuda()
y = torch.from_numpy(y).cuda()
return 1 - F.cosine_similarity(x[:, None, :], y[None, :, :], 2)
# Exclude identical-view cases
def de_diag(acc, each_angle=False):
view_num = acc.shape[0]
result = np.sum(acc - np.diag(np.diag(acc)), 1) / (view_num - 1)
if not each_angle:
result = np.mean(result)
return result
class BaselineSolver(Solver):
def train(self):
self.build_data()
self.build_model()
self.build_optimizer()
self.build_loss()
start_time = time.time()
self.iter = 0
# Print out configurations
self.print_log('{} samples in train set'.format(
len(self.trainloader.dataset)))
self.print_log('{} samples in test set'.format(
len(self.testloader.dataset)))
if self.cfg.print_model:
self.print_log('Architecture:\n{}'.format(self.model))
num_params = sum(p.numel() for p in self.model.parameters() if p.requires_grad)
self.print_log('Parameters: {}'.format(num_params))
self.print_log('Configurations:\n{}\n'.format(
json.dumps(vars(self.cfg), indent=4)))
# Load from previous checkpoints
self.load()
self.best_acc, self.best_iter = [0], -1
meters = defaultdict(lambda: AverageMeter())
end = time.time()
for seq, view, seq_type, label in self.trainloader:
self.model.train()
meters['dataTime'].update(time.time() - end)
end = time.time()
lr = self.lr_scheduler.step(self.iter)
self.iter += 1
seq, label = seq.float().cuda(), label.long().cuda()
feature = self.model(seq)
loss, loss_num = self.loss(feature, label)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
# record loss
meters['modelTime'].update(time.time() - end)
meters['loss'].update(loss)
meters['lossNum'].update(loss_num)
# show log info
if self.iter % self.cfg.log_interval == 0:
self.print_log('Iter: {}/{}'.format(self.iter, self.cfg.num_iter) +
' - Data: {:.0f}s'.format(meters['dataTime'].sum) +
' - Model: {:.0f}s'.format(meters['modelTime'].sum) +
' - Lr: {:.2e}'.format(lr) +
' - Loss: {:.2f}'.format(meters['loss'].avg) +
' - Num: {:.2e}'.format(meters['lossNum'].avg))
for i in ['loss', 'lossNum']:
self.writer.add_scalar('train/{}'.format(i), meters[i].avg, self.iter)
for m in meters.values():
m.reset()
# save checkpoints
self.save()
# test
if self.iter % self.cfg.test_interval == 0:
acc = self._test()
self.collect(acc)
# show distributions of weights and grads
self.show_info()
# End
if self.iter == self.cfg.num_iter:
self.print_log('\nBest Acc: {}'.format(self.best_acc) +
'\nIter: {}'.format(self.best_iter) +
'\nDir: {}'.format(self.work_dir) +
'\nTime: {}'.format(
self._convert_time(time.time() - start_time)))
return
end = time.time()
def show_info(self, with_weight=True, with_grad=True):
if with_weight:
for name, param in self.model.named_parameters():
w = param.data.cpu().numpy()
self.writer.add_histogram('weight_info/{}'.format(name), w, self.iter)
if with_grad:
for name, param in self.model.named_parameters():
if param.grad is not None:
w = param.grad.cpu().numpy()
self.writer.add_histogram('grad_info/{}'.format(name), w, self.iter)
def collect(self, acc):
acc_avg = sum(acc) / len(acc)
best_avg = sum(self.best_acc) / len(self.best_acc)
if acc_avg > best_avg:
self.best_acc = acc
self.best_iter = self.iter
# save the best
path = os.path.join(self.work_dir, self.cfg.save_name+'.pth.tar')
return self.save_checkpoint(path)
def test(self):
self.build_data()
self.build_model()
if self.cfg.pretrained is None:
raise ValueError('Please appoint --pretrained.')
self.iter = self.load_checkpoint(self.cfg.pretrained, optim=False)
return self._test()
def _test(self):
self.model.eval()
feature_list = list()
view_list = list()
seq_type_list = list()
label_list = list()
for i, x in enumerate(self.testloader):
seq, view, seq_type, label = x
seq = seq.float().cuda()
feature = self.model(seq)
n = feature.size(0)
feature_list.append(feature.view(n, -1).data.cpu().numpy())
view_list += view
seq_type_list += seq_type
label_list.append(label.item())
acc = self._compute_accuracy(feature_list, view_list, seq_type_list,
label_list)
if len(acc) > 1:
self.writer.add_scalar('test/accNM', acc[0], self.iter)
self.writer.add_scalar('test/accBG', acc[1], self.iter)
self.writer.add_scalar('test/accCL', acc[2], self.iter)
else:
self.writer.add_scalar('test/acc', acc[0], self.iter)
return acc
def _compute_accuracy(self, feature, view, seq_type, label,
metric='euclidean'):
_metrics = {'euclidean': euclidean_dist, 'cosine': cosine_dist}
dist_metric = _metrics[metric]
feature = np.concatenate(feature, 0)
label = np.array(label)
view_list = list(set(view))
view_list.sort()
view_num = len(view_list)
sample_num = len(feature)
probe_seq_dict = {'CASIA': [['nm-05', 'nm-06'], ['bg-01', 'bg-02'], ['cl-01', 'cl-02']],
'OUMVLP': [['00']]}
gallery_seq_dict = {'CASIA': [['nm-01', 'nm-02', 'nm-03', 'nm-04']],
'OUMVLP': [['01']]}
num_rank = 5
dataset = 'CASIA' if 'CASIA' in self.cfg.dataset else 'OUMVLP'
acc = np.zeros([len(probe_seq_dict[dataset]), view_num, view_num, num_rank])
for (p, probe_seq) in enumerate(probe_seq_dict[dataset]):
for gallery_seq in gallery_seq_dict[dataset]:
for (v1, probe_view) in enumerate(view_list):
for (v2, gallery_view) in enumerate(view_list):
gseq_mask = | np.isin(seq_type, gallery_seq) | numpy.isin |
import numpy as np
from pyNastran.femutils.utils import unique2d
from pyNastran.dev.bdf_vectorized.utils import slice_to_iter
from pyNastran.dev.bdf_vectorized.cards.elements.solid.ctetra4 import volume4
from pyNastran.dev.bdf_vectorized.cards.elements.solid.chexa8 import quad_area_centroid
from pyNastran.dev.bdf_vectorized.cards.elements.solid.cpenta6 import tri_area_centroid
from pyNastran.dev.bdf_vectorized.cards.elements.shell.cquad4 import _cquad4_normal_A
from pyNastran.dev.bdf_vectorized.cards.elements.shell.ctria3 import _ctria3_normal_A
from pyNastran.dev.bdf_vectorized.cards.elements.utils import build_groups, asarray
from pyNastran.dev.bdf_vectorized.cards.vectorized_card import BaseMethods
class Elements(BaseMethods):
def __init__(self, model):
"""
Defines the Elements object.
Parameters
----------
model : BDF
the BDF object
"""
self.model = model
self.n = 0
self.nelements = 0
self.nproperties = 0
self.element_ids = None
self.property_ids = None
self.element_groups = None
self.property_groups = None
#: stores PSHELL, PCOMP, PCOMPG
self.properties_shell = model.properties_shell
#: stores CTRIA3, CTRIA6, CQUAD4, CQUAD8
self.elements_shell = model.elements_shell
# shear
#: stores CSHEAR
self.cshear = model.cshear
#: stores PSHEAR
self.pshear = model.pshear
# rigid
#self.rbe2 = model.rbe2
#self.rbe3 = model.rbe3
# spring
self.elements_spring = model.elements_spring
self.pelas = model.pelas
# bushings
self.cbush = model.cbush
self.cbush1d = model.cbush1d
self.cbush2d = model.cbush2d
self.pbush = model.pbush
# rods
self.conrod = model.conrod
self.prod = model.prod
self.crod = model.crod
self.ctube = model.ctube
self.ptube = model.ptube
# mass
#: stores CONM1, CONM2, CMASS1, CMASS2, CMASS3, CMASS4, CMASS5, PMASS
self.mass = model.mass
#self.conm1 = model.conm1
#self.conm2 = model.conm2
#self.cmass1 = self.cmass1
#self.cmass1 = self.cmass1
#self.cmass2 = self.cmass2
#self.cmass3 = self.cmass3
#self.cmass4 = self.cmass4
#self.cmass5 = self.cmass5
# bars
#: stores CBAR
self.cbar = model.cbar
#: stores PBAR, PBARL
self.properties_bar = model.properties_bar
# beams
#: stores CBEAM
self.cbeam = model.cbeam
#: stores PBEAM, PBEAML
self.properties_beam = model.properties_beam
# solids
#: stores CTETRA4, CPENTA6, CHEXA8, CTETRA10, CPENTA15, CHEXA20
self.elements_solid = model.elements_solid
#: stores PSOLID, PLSOLID
self.properties_solid = model.properties_solid
def validate_nodes(self, elements):
validate_nodes = False
if not hasattr(elements, 'node_ids'):
# this element isn't finished
return
if not validate_nodes:
# no checks
return
grids = self.model.grid.node_id
nids = np.unique(np.ravel(elements.node_ids))
#nids.sort()
diff = np.setdiff1d(nids, grids)
if len(diff):
eids = []
# find the bad elements
for i, eid in enumerate(elements.element_id):
j = np.intersect1d(diff, elements.node_ids[i, :])
if len(j):
eids.append(eid)
# prevents really long arrays
eids = np.array(eids)
msg = "Couldn't find Node ID: %s, which is required by %s %s" % (
diff, elements.type, eids)
raise RuntimeError(msg)
def build(self):
#print('elements')
self.n = 0
self._build_elements()
self._build_properties()
old_build = False
if old_build:
etypes = self._get_element_types(nlimit=False)
ptypes = self._get_property_types(nlimit=False)
for elems in etypes:
#if elems is None:
#continue
if hasattr(elems, 'type'):
if elems.type in self.model.card_count:
self.model.log.debug('building %s' % elems.__class__.__name__)
else:
#if elems.n:
self.model.log.debug('building %s' % elems.__class__.__name__)
elems.build()
self.nelements += elems.n
self.validate_nodes(elems)
#print(nids - grids[i])
for props in ptypes:
#if props is None:
#continue
if hasattr(props, 'type'):
if props.type in self.model.card_count:
self.model.log.debug('building %s' % props.__class__.__name__)
else:
#if props.n:
self.model.log.debug('building %s' % props.__class__.__name__)
props.build()
self.nproperties += props.n
else:
etypes = self._get_element_types(nlimit=True)
ptypes = self._get_property_types(nlimit=True)
self.model.log.debug('etypes = %s' % etypes)
self.model.log.debug('ptypes = %s' % ptypes)
for elems in etypes:
#if elems.type in ['CONROD']:
#self.nproperties += elems.n
self.nelements += elems.n
self.validate_nodes(elems)
for props in ptypes:
self.nproperties += props.n
self.model.log.debug('finished building %s' % self.__class__.__name__)
if self.nelements:
eids = check_duplicate('element_id', etypes, self.model.log)
self.element_ids = asarray(eids, dtype='int32')
self.element_ids.sort()
self.element_groups = build_groups(etypes, 'element_id', is_element=True)
#self.model.log.info('self.element_groups = %s' % self.element_groups)
else:
self.model.log.warning('no elements...')
if self.nproperties:
pids = check_duplicate('property_id', ptypes, self.model.log)
self.property_ids = asarray(pids, dtype='int32')
self.property_ids.sort()
self.property_groups = build_groups(ptypes, 'property_id')
self.model.log.info('self.property_groups = %s' % self.property_groups)
#print('*****self.element_ids =', self.element_ids)
#print('*****self.property_ids =', self.property_ids)
def get_elements(self, element_id):
type_map = {
'CELAS1' : self.elements_spring.celas1,
'CELAS2' : self.elements_spring.celas2,
'CELAS3' : self.elements_spring.celas3,
'CELAS4' : self.elements_spring.celas4,
#'CBUSH' : self.elements_bush.cbush,
#'CBUSH1D' : self.elements_bush.cbush1d,
#'CBUSH2D' : self.elements_bush.cbush2d,
'CBUSH' : self.cbush,
'CBUSH1D' : self.cbush1d,
'CBUSH2D' : self.cbush2d,
'CROD' : self.crod,
'CTUBE' : self.ctube,
'CONROD' : self.conrod,
'CSHEAR' : self.cshear,
'CTRIA3' : self.elements_shell.ctria3,
'CQUAD4' : self.elements_shell.cquad4,
'CTRIA6' : self.elements_shell.ctria6,
'CQUAD8' : self.elements_shell.cquad8,
'CTETRA4' : self.elements_solid.ctetra4,
'CPENTA6' : self.elements_solid.cpenta6,
'CHEXA8' : self.elements_solid.chexa8,
'CTETRA10' : self.elements_solid.ctetra10,
'CPENTA15' : self.elements_solid.cpenta15,
'CHEXA20' : self.elements_solid.chexa20,
}
out = []
for eid in element_id:
obj = None
for etype, eids in self.element_groups.items():
if eid in eids:
i = np.where(eid == eids)[0]
obj = type_map[etype][i]
out.append(obj)
return out
def get_element_properties(self, exclude_types=None):
if exclude_types is None:
exclude_types = []
element_objs = [
self.elements_spring.celas1, self.elements_spring.celas2,
self.elements_spring.celas3, self.elements_spring.celas4,
self.cshear,
self.crod, self.conrod, self.ctube,
self.cbar, self.cbeam,
self.cbush, self.cbush1d, self.cbush2d,
self.elements_shell.ctria3, self.elements_shell.cquad4,
self.elements_shell.ctria6, self.elements_shell.cquad8,
self.elements_solid.ctetra4, self.elements_solid.cpenta6, self.elements_solid.chexa8,
self.elements_solid.ctetra10, self.elements_solid.cpenta15, self.elements_solid.chexa20,
]
if exclude_types is None:
exclude_types = []
element_objs2 = []
for element_obj in element_objs:
if element_obj.type not in exclude_types:
element_objs2.append(element_obj)
element_objs = element_objs2
del element_objs2
# this isn't working...
#element_objs = [element_obj if element_obj.type not in exclude_types
#for element_obj in element_objs]
elements_without_properties = ['CELAS2', 'CELAS4', 'CONROD']
eids = np.hstack([element_obj.element_id for element_obj in element_objs])
pids = np.hstack([np.zeros(element_obj.n, dtype='int32')
if element_obj.type in elements_without_properties
else element_obj.property_id for element_obj in element_objs])
return element_objs, eids, pids
def get_element_ids_by_property_type(self, element_ids, exclude_types=None):
#self.model.log.debug('element_ids = %s' % element_ids)
Types, eids, pids = self.get_element_properties(exclude_types)
# remove undefined properties
#existing_pids = setdiff1d(unique(pids), self.property_ids, assume_unique=True)
#self.model.log.debug('pids = %s' % pids)
#self.model.log.debug('self.property_ids = %s' % self.property_ids)
#self.model.log.debug('existing_pids = %s' % existing_pids)
# make sure oids is unique
oids = np.hstack([Type.op2_id for Type in Types])
oids2 = np.unique(oids)
assert len(oids) == len(oids2), oids
oids = np.hstack([Type.op2_id * np.ones(Type.n, dtype='int32') for Type in Types])
i = np.argsort(eids)
#self.model.log.debug('i = %s' % i)
#self.model.log.debug('eids = %s len=%s' % (eids, len(eids)))
#self.model.log.debug('pids = %s len=%s' % (pids, len(pids)))
#self.model.log.debug('oids = %s len=%s' % (oids, len(oids)))
assert len(eids) == len(pids), 'len(eids)=%i len(pids)=%i' % (len(eids), len(pids))
assert len(eids) == len(oids), 'len(eids)=%i len(oids)=%i' % (len(eids), len(oids))
eids = eids[i]
pids = pids[i]
oids = oids[i]
data = np.vstack([eids, pids, oids]).T
#self.model.log.debug(data)
# drop extra elements
# for eids greater than the max allowable eid located at data[-1,0],
# we drop them
i_less = np.where(data[-1, 0] >= element_ids)[0]
element_ids = element_ids[i_less]
# drop more extra elements
# we're handling cases of skipped elements (e.g. CELASx cards)
# that have a sorted location in data, but no unique value
#print('++++++ %s' % element_ids)
#print('++++++ %s' % data[:, 0])
ie = np.unique(np.searchsorted(data[:, 0], element_ids))
#print('ie = %s' % ie)
#print('dataA \n%s' % data)
return data[ie, :]
#return data
def get_nodes(self, node_id, xyz_cid0, msg=''):
i = self.model.grid.get_node_index_by_node_id(node_id, msg=msg)
return xyz_cid0[i, :]
def _get_element_ids(self, element_ids_orig):
if element_ids_orig is None:
element_ids = self.element_ids
element_ids_orig = element_ids
#print('A %s' % element_ids)
else:
# remove elements that don't exist in the BDF
#print("self.element_ids = \n%s" % str(self.element_ids))
#print("element_ids = \n%s" % str(element_ids))
element_ids_orig = asarray(element_ids_orig)
element_ids = np.intersect1d(element_ids_orig, self.element_ids)
# check for invalid IDs
#n = len(element_ids)
#i = where(element_ids < 1)[0] # < 100000000
#j = where(element_ids[i] > 99999999)[0]
#if len(i) + len(j):
#eids = setdiff1d(element_ids[i[j]], element_ids)
#eids = '???'
#raise RuntimeError('0 < element_ids < 100000000 is invalid; eids=%s' % eids)
#element_ids = element_ids[i[j]]
#print('B %s' % element_ids)
return element_ids, element_ids_orig
def get_mass_by_element_id(self, element_ids_orig=None, xyz_cid0=None, sort_output=True):
if xyz_cid0 is None:
xyz_cid0 = self.model.grid.get_position_by_node_index()
element_ids, element_ids_orig = self._get_element_ids(element_ids_orig)
if len(element_ids) == 0:
nelements = len(element_ids_orig)
mass = np.full(nelements, np.nan, 'float64')
if sort_output:
i = np.argsort(element_ids_orig)
#print("i =", i, i.shape)
#print("element_ids_orig =", element_ids_orig, element_ids_orig.shape)
return element_ids_orig[i], mass
else:
return element_ids_orig, mass
nelements_orig = len(element_ids_orig)
#print('eids orig = %s' % element_ids_orig)
type_map = {
#'CELAS1' : self.elements_spring.celas1,
'CELAS2' : self.elements_spring.celas2,
'CELAS3' : self.elements_spring.celas3,
'CELAS4' : self.elements_spring.celas4,
'CBAR' : self.cbar,
'CBEAM' : self.cbeam,
'CROD' : self.crod,
'CONROD' : self.conrod,
'CTUBE' : self.ctube,
'CSHEAR' : self.cshear,
'CQUAD4' : self.elements_shell.cquad4,
'CTRIA3' : self.elements_shell.ctria3,
'CTETRA4' : self.elements_solid.ctetra4,
'CPENTA6' : self.elements_solid.cpenta6,
'CHEXA8' : self.elements_solid.chexa8,
'CTETRA10' : self.elements_solid.ctetra10,
'CPENTA15' : self.elements_solid.cpenta15,
'CHEXA20' : self.elements_solid.chexa20,
}
exclude_types = [
'CELAS1', 'CELAS2', 'CELAS3', 'CELAS4',
'CDAMP1', 'CDAMP2', 'CDAMP3', 'CDAMP4',
'CMASS1', 'CMASS2', 'CMASS3', 'CMASS4',
'CBUSH', 'CBUSH1D', 'CBUSH2D',
]
pid_data = self.get_element_ids_by_property_type(element_ids, exclude_types=exclude_types)
element_ids_to_analyze = pid_data[:, 0]
data2 = self.group_elements_by_property_type_and_element_type(self, pid_data)
#self.model.log.debug('**data2 = %s' % data2)
nelements = len(element_ids)
#self.model.log.debug('nelement_ids =', nelements)
eids2 = np.zeros(nelements_orig, dtype='int32')
#mass = full(nelements, nan, dtype='float64')
mass = np.full(nelements_orig, np.nan, dtype='float64')
#self.model.log.debug('mass.shape =', mass.shape)
ni = 0
self.model.log.debug('data2 = %s' % data2)
for (pid, etype), element_ids in data2.items():
#self.model.log.debug('pid=%s eType=%s element_ids=%s' % (pid, eType, element_ids))
elements = type_map[etype]
i = np.searchsorted(elements.element_id, element_ids)
n = len(i)
eids2[ni:ni+n] = elements.element_id[i]
if pid == 0:
# CONROD
pass
else:
self.model.log.debug('*cat pid = %s' % pid)
props = self.get_properties([pid])
if len(props) == 0:
# the property doesn't exist
self.model.log.debug('Property %i does not exist and is needed by %s eid=%i' % (
pid, etype, element_ids[0]))
ni += n
#print('props = %s' % props)
continue
# we only get one property at a time
prop = props[0]
#print(' prop = %s' % str(prop).rstrip())
elements = type_map[etype]
i = np.searchsorted(elements.element_id, element_ids)
n = len(i)
#print('ielements = %s' % i)
if etype in ['CELAS1', 'CELAS2', 'CELAS3', 'CELAS4',]:
pass
elif etype in ['CROD', 'CONROD', 'CBAR', 'CBEAM']:
msg = ', which is required for %ss' % etype
n1 = self.get_nodes(elements.node_ids[i, 0], xyz_cid0, msg=msg)
n2 = self.get_nodes(elements.node_ids[i, 1], xyz_cid0, msg=msg)
length = | np.linalg.norm(n2 - n1, axis=1) | numpy.linalg.norm |
# pylint: disable=C0114,C0115,C0116
import unittest
import numpy as np
from scipy import constants as const
from nonrad.scaling import (charged_supercell_scaling,
charged_supercell_scaling_VASP, distance_PBC,
find_charge_center, radial_distribution,
sommerfeld_parameter, thermal_velocity)
from nonrad.tests import TEST_FILES, FakeFig
class SommerfeldTest(unittest.TestCase):
def setUp(self):
self.args = {
'T': 300,
'Z': 0,
'm_eff': 1.,
'eps0': 1.,
'method': 'Integrate'
}
def test_neutral(self):
self.assertAlmostEqual(sommerfeld_parameter(**self.args), 1.)
self.args['method'] = 'Analytic'
self.assertAlmostEqual(sommerfeld_parameter(**self.args), 1.)
def test_attractive(self):
self.args['Z'] = -1
self.assertGreater(sommerfeld_parameter(**self.args), 1.)
self.args['method'] = 'Analytic'
self.assertGreater(sommerfeld_parameter(**self.args), 1.)
def test_repulsive(self):
self.args['Z'] = 1
self.assertLess(sommerfeld_parameter(**self.args), 1.)
self.args['method'] = 'Analytic'
self.assertLess(sommerfeld_parameter(**self.args), 1.)
def test_list(self):
self.args['T'] = np.linspace(0.1, 1000, 100)
self.assertEqual(sommerfeld_parameter(**self.args), 1.)
self.args['Z'] = -1
self.assertTrue(np.all(sommerfeld_parameter(**self.args) > 1.))
self.args['Z'] = 1
self.assertTrue(np.all(sommerfeld_parameter(**self.args) < 1.))
self.args['Z'] = 0
self.args['method'] = 'Analytic'
self.assertEqual(sommerfeld_parameter(**self.args), 1.)
self.args['Z'] = -1
self.assertTrue(np.all(sommerfeld_parameter(**self.args) > 1.))
self.args['Z'] = 1
self.assertTrue(np.all(sommerfeld_parameter(**self.args) < 1.))
def test_compare_methods(self):
self.args = {
'T': 150,
'Z': -1,
'm_eff': 0.2,
'eps0': 8.9,
'method': 'Integrate'
}
f0 = sommerfeld_parameter(**self.args)
self.args['method'] = 'Analytic'
f1 = sommerfeld_parameter(**self.args)
self.assertAlmostEqual(f0, f1, places=2)
self.args['Z'] = 1
self.args['T'] = 900
f0 = sommerfeld_parameter(**self.args)
self.args['method'] = 'Integrate'
f1 = sommerfeld_parameter(**self.args)
self.assertGreater(np.abs(f0-f1)/f1, 0.1)
class ChargedSupercellScalingTest(unittest.TestCase):
def test_find_charge_center(self):
lattice = np.eye(3)
density = np.ones((50, 50, 50))
self.assertTrue(
np.allclose(find_charge_center(density, lattice), [0.49]*3)
)
density = np.zeros((50, 50, 50))
density[0, 0, 0] = 1.
self.assertTrue(
np.allclose(find_charge_center(density, lattice), [0.]*3)
)
def test_distance_PBC(self):
a = np.array([0.25]*3)
b = np.array([0.5]*3)
lattice = np.eye(3)
self.assertEqual(distance_PBC(a, b, lattice), np.sqrt(3)*0.25)
b = np.array([0.9]*3)
self.assertEqual(distance_PBC(a, b, lattice), np.sqrt(3)*0.35)
def test_radial_distribution(self):
lattice = np.eye(3)
density = np.zeros((50, 50, 50))
density[0, 0, 0] = 1.
point = np.array([0.]*3)
dist = distance_PBC(np.zeros(3), point, lattice)
r, n = radial_distribution(density, point, lattice)
self.assertAlmostEqual(r[np.where(n == 1.)[0][0]], dist)
point = np.array([0.25]*3)
dist = distance_PBC(np.zeros(3), point, lattice)
r, n = radial_distribution(density, point, lattice)
self.assertAlmostEqual(r[np.where(n == 1.)[0][0]], dist)
point = np.array([0.29, 0.73, 0.44])
dist = distance_PBC(np.zeros(3), point, lattice)
r, n = radial_distribution(density, point, lattice)
self.assertAlmostEqual(r[ | np.where(n == 1.) | numpy.where |
# The MIT License (MIT)
#
# Copyright (c) 2016-2019 <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.
"""One-dimensional histograms."""
from typing import Optional, Tuple
import numpy as np
from . import bin_utils
from .histogram_base import HistogramBase
from .binnings import BinningBase
import pandas
# TODO: Fix I/O with binning
class Histogram1D(HistogramBase):
"""One-dimensional histogram data.
The bins can be of different widths.
The bins need not be consecutive.
However, some functionality may not be available
for non-consecutive bins
(like keeping information about underflow and overflow).
Attributes
----------
_stats : dict
These are the basic attributes
that can be used in the constructor (see there)
Other attributes are dynamic.
"""
def __init__(
self, binning, frequencies=None, errors2=None, *, stats=None, **kwargs
):
"""Constructor
Parameters
----------
binning: physt.binnings.BinningBase or array_like
The binning
frequencies: Optional[array_like]
The bin contents.
keep_missed: Optional[bool]
Whether to keep track of underflow/overflow
when filling with new values.
underflow: Optional[float]
Weight of observations that were smaller than the minimum bin.
overflow: Optional[float]
Weight of observations that were larger than the maximum bin.
name: Optional[str]
Name of the histogram (will be displayed as plot title)
axis_name: Optional[str]
Name of the characteristics that is histogrammed
(will be displayed on x axis)
errors2: Optional[array_like]
Quadratic errors of individual bins.
If not set, defaults to frequencies.
stats: dict
Dictionary of various statistics ("sum", "sum2")
"""
missed = [
kwargs.pop("underflow", 0),
kwargs.pop("overflow", 0),
kwargs.pop("inner_missed", 0),
]
if "axis_name" in kwargs:
kwargs["axis_names"] = [kwargs.pop("axis_name")]
HistogramBase.__init__(self, [binning], frequencies, errors2, **kwargs)
if frequencies is None:
self._stats = Histogram1D.EMPTY_STATS.copy()
else:
self._stats = stats
if self.keep_missed:
self._missed = np.array(missed, dtype=self.dtype)
else:
self._missed = np.zeros(3, dtype=self.dtype)
EMPTY_STATS = {"sum": 0.0, "sum2": 0.0}
@property
def axis_name(self) -> str:
return self.axis_names[0]
@axis_name.setter
def axis_name(self, value: str):
self.axis_names = (value,)
def select(self, axis, index, force_copy: bool = False):
"""Alias for [] to be compatible with HistogramND."""
if axis == 0:
if index == slice(None) and not force_copy:
return self
return self[index]
else:
raise ValueError("In Histogram1D.select(), axis must be 0.")
def __getitem__(self, i):
"""Select sub-histogram or get one bin.
Parameters
----------
i : int or slice or bool masked array or array with indices
In most cases, this has same semantics
as for numpy.ndarray.__getitem__
Returns
-------
Histogram1D or tuple
Depending on the parameters, a sub-histogram
or content of one bin are returned.
"""
underflow = np.nan
overflow = np.nan
keep_missed = False
if isinstance(i, int):
return self.bins[i], self.frequencies[i]
elif isinstance(i, np.ndarray):
if i.dtype == bool:
if i.shape != (self.bin_count,):
raise IndexError(
"Cannot index with masked array " "of a wrong dimension"
)
elif isinstance(i, slice):
keep_missed = self.keep_missed
# TODO: Fix this
if i.step:
raise IndexError("Cannot change the order of bins")
if i.step == 1 or i.step is None:
underflow = self.underflow
overflow = self.overflow
if i.start:
underflow += self.frequencies[0 : i.start].sum()
if i.stop:
overflow += self.frequencies[i.stop :].sum()
# Masked arrays or item list or ...
return self.__class__(
self._binning.as_static(copy=False)[i],
self.frequencies[i],
self.errors2[i],
overflow=overflow,
keep_missed=keep_missed,
underflow=underflow,
dtype=self.dtype,
name=self.name,
axis_name=self.axis_name,
)
@property
def _binning(self) -> BinningBase:
"""Adapter property for HistogramBase interface"""
return self._binnings[0]
@_binning.setter
def _binning(self, value: BinningBase):
self._binnings = [value]
@property
def binning(self) -> BinningBase:
"""The binning.
Note: Please, do not try to update the object itself.
"""
return self._binning
@property
def bins(self) -> np.ndarray:
"""Array of all bin edges.
Returns
-------
Wide-format [[leftedge1, rightedge1], ... [leftedgeN, rightedgeN]]
"""
# TODO: Read-only copy
return self._binning.bins # TODO: or this should be read-only copy?
@property
def numpy_bins(self) -> np.ndarray:
"""Bins in the format of numpy.
"""
# TODO: If not consecutive, does not make sense
# TODO: Deprecate
return self._binning.numpy_bins
@property
def edges(self) -> np.ndarray:
return self.numpy_bins
@property
def numpy_like(self) -> Tuple[np.ndarray, np.ndarray]:
"""Same result as would the numpy.histogram function return."""
return self.frequencies, self.numpy_bins
@property
def cumulative_frequencies(self) -> np.ndarray:
"""Cumulative frequencies.
Note: underflow values are not considered
"""
return self._frequencies.cumsum()
@property
def underflow(self):
if not self.keep_missed:
return np.nan
return self._missed[0]
@underflow.setter
def underflow(self, value):
self._missed[0] = value
@property
def overflow(self):
if not self.keep_missed:
return np.nan
return self._missed[1]
@overflow.setter
def overflow(self, value):
self._missed[1] = value
@property
def inner_missed(self):
if not self.keep_missed:
return np.nan
return self._missed[2]
@inner_missed.setter
def inner_missed(self, value):
self._missed[2] = value
def mean(self) -> Optional[float]:
"""Statistical mean of all values entered into histogram.
This number is precise, because we keep the necessary data
separate from bin contents.
"""
if self._stats: # TODO: should be true always?
if self.total > 0:
return self._stats["sum"] / self.total
else:
return np.nan
else:
return None # TODO: or error
def std(self) -> Optional[float]: # , ddof=0):
"""Standard deviation of all values entered into histogram.
This number is precise, because we keep the necessary data
separate from bin contents.
Returns
-------
float
"""
# TODO: Add DOF
if self._stats:
return np.sqrt(self.variance())
else:
return None # TODO: or error
def variance(self) -> Optional[float]: # , ddof: int = 0) -> float:
"""Statistical variance of all values entered into histogram.
This number is precise, because we keep the necessary data
separate from bin contents.
Returns
-------
float
"""
# TODO: Add DOF
# http://stats.stackexchange.com/questions/6534/how-do-i-calculate-a-weighted-standard-deviation-in-excel
if self._stats:
if self.total > 0:
return (
self._stats["sum2"] - self._stats["sum"] ** 2 / self.total
) / self.total
else:
return np.nan
else:
return None
# TODO: Add (correct) implementation of SEM
# def sem(self):
# if self._stats:
# return 1 / total * np.sqrt(self.variance)
# else:
# return None
@property
def bin_left_edges(self):
"""Left edges of all bins.
Returns
-------
numpy.ndarray
"""
return self.bins[..., 0]
@property
def bin_right_edges(self):
"""Right edges of all bins.
Returns
-------
numpy.ndarray
"""
return self.bins[..., 1]
@property
def min_edge(self):
"""Left edge of the first bin.
Returns
-------
float
"""
return self.bin_left_edges[0]
@property
def max_edge(self):
"""Right edge of the last bin.
Returns
-------
float
"""
# TODO: Perh
return self.bin_right_edges[-1]
@property
def bin_centers(self):
"""Centers of all bins.
Returns
-------
numpy.ndarray
"""
return (self.bin_left_edges + self.bin_right_edges) / 2
@property
def bin_widths(self):
"""Widths of all bins.
Returns
-------
numpy.ndarray
"""
return self.bin_right_edges - self.bin_left_edges
@property
def total_width(self):
"""Total width of all bins.
In inconsecutive histograms, the missing intervals are not counted in.
Returns
-------
float
"""
return self.bin_widths.sum()
@property
def bin_sizes(self):
return self.bin_widths
def find_bin(self, value):
"""Index of bin corresponding to a value.
Parameters
----------
value: float
Value to be searched for.
Returns
-------
int
index of bin to which value belongs
(-1=underflow, N=overflow, None=not found - inconsecutive)
"""
ixbin = np.searchsorted(self.bin_left_edges, value, side="right")
if ixbin == 0:
return -1
elif ixbin == self.bin_count:
if value <= self.bin_right_edges[-1]:
return ixbin - 1
else:
return self.bin_count
elif value < self.bin_right_edges[ixbin - 1]:
return ixbin - 1
elif ixbin == self.bin_count:
return self.bin_count
else:
return None
def fill(self, value, weight=1):
"""Update histogram with a new value.
Parameters
----------
value: float
Value to be added.
weight: float, optional
Weight assigned to the value.
Returns
-------
int
index of bin which was incremented
(-1=underflow, N=overflow, None=not found)
Note: If a gap in unconsecutive bins is matched,
underflow & overflow are not valid anymore.
Note: Name was selected because of the eponymous method in ROOT
"""
self._coerce_dtype(type(weight))
if self._binning.is_adaptive():
map = self._binning.force_bin_existence(value)
self._reshape_data(self._binning.bin_count, map)
ixbin = self.find_bin(value)
if ixbin is None:
self.overflow = np.nan
self.underflow = np.nan
elif ixbin == -1 and self.keep_missed:
self.underflow += weight
elif ixbin == self.bin_count and self.keep_missed:
self.overflow += weight
else:
self._frequencies[ixbin] += weight
self._errors2[ixbin] += weight ** 2
if self._stats:
self._stats["sum"] += weight * value
self._stats["sum2"] += weight * value ** 2
return ixbin
def fill_n(self, values, weights=None, dropna: bool = True):
"""Update histograms with a set of values.
Parameters
----------
values: array_like
weights: Optional[array_like]
drop_na: Optional[bool]
If true (default), all nan's are skipped.
"""
# TODO: Unify with HistogramBase
values = np.asarray(values)
if dropna:
values = values[~np.isnan(values)]
if self._binning.is_adaptive():
map = self._binning.force_bin_existence(values)
self._reshape_data(self._binning.bin_count, map)
if weights is not None:
weights = np.asarray(weights)
self._coerce_dtype(weights.dtype)
(frequencies, errors2, underflow, overflow, stats) = calculate_frequencies(
values,
self._binning,
dtype=self.dtype,
weights=weights,
validate_bins=False,
)
self._frequencies += frequencies
self._errors2 += errors2
# TODO: check that adaptive does not produce under-/over-flows?
if self.keep_missed:
self.underflow += underflow
self.overflow += overflow
if self._stats:
for key in self._stats:
self._stats[key] += stats.get(key, 0.0)
def __eq__(self, other):
if not isinstance(other, self.__class__):
return False
# TODO: Change to something in binning itself
if not np.allclose(other.bins, self.bins):
return False
if not np.allclose(other.frequencies, self.frequencies):
return False
if not np.allclose(other.errors2, self.errors2):
return False
if not other.overflow == self.overflow:
return False
if not other.underflow == self.underflow:
return False
if not other.inner_missed == self.inner_missed:
return False
if not other.name == self.name:
return False
if not other.axis_name == self.axis_name:
return False
return True
def to_dataframe(self) -> "pandas.DataFrame":
"""Convert to pandas DataFrame.
This is not a lossless conversion - (under/over)flow info is lost.
"""
import pandas as pd
df = pd.DataFrame(
{
"left": self.bin_left_edges,
"right": self.bin_right_edges,
"frequency": self.frequencies,
"error": self.errors,
},
columns=["left", "right", "frequency", "error"],
)
return df
@classmethod
def _kwargs_from_dict(cls, a_dict: dict) -> dict:
kwargs = HistogramBase._kwargs_from_dict.__func__(cls, a_dict)
kwargs["binning"] = kwargs.pop("binnings")[0]
return kwargs
def calculate_frequencies(
data, binning, weights=None, validate_bins=True, already_sorted=False, dtype=None
):
"""Get frequencies and bin errors from the data.
Parameters
----------
data : array_like
Data items to work on.
binning : physt.binnings.BinningBase
A set of bins.
weights : array_like, optional
Weights of the items.
validate_bins : bool, optional
If True (default), bins are validated to be in ascending order.
already_sorted : bool, optional
If True, the data being entered are already sorted,
no need to sort them once more.
dtype: Optional[type]
Underlying type for the histogram.
(If weights are specified, default is float. Otherwise long.)
Returns
-------
frequencies : numpy.ndarray
Bin contents
errors2 : numpy.ndarray
Error squares of the bins
underflow : float
Weight of items smaller than the first bin
overflow : float
Weight of items larger than the last bin
stats: dict
{ sum: ..., sum2: ...}
Note
----
Checks that the bins are in a correct order (not necessarily consecutive).
Does not check for numerical overflows in bins.
"""
# TODO: Is it possible to merge with histogram_nd.calculate_frequencies?
# TODO: What if data is None
# TODO: Change stats into namedtuple
# Statistics
sum = 0.0
sum2 = 0.0
# Ensure correct binning
bins = binning.bins # bin_utils.make_bin_array(bins)
if validate_bins:
if bins.shape[0] == 0:
raise RuntimeError("Cannot have histogram with 0 bins.")
if not bin_utils.is_rising(bins):
raise RuntimeError("Bins must be rising.")
# Prepare 1D numpy array of data
data = np.asarray(data)
if data.ndim > 1:
data = data.flatten()
# Prepare 1D numpy array of weights
if weights is not None:
weights = np.asarray(weights)
if weights.ndim > 1:
weights = weights.flatten()
# Check compatibility of weights
if weights.shape != data.shape:
raise RuntimeError("Weights must have the same shape as data.")
# Ensure proper dtype for the bin contents
if dtype is None:
dtype = weights.dtype
if dtype is None:
dtype = int
dtype = np.dtype(dtype)
if dtype.kind in "iu" and weights is not None and weights.dtype.kind == "f":
raise RuntimeError("Integer histogram requested " "but float weights entered.")
# Data sorting
if not already_sorted:
args = np.argsort(data) # Memory: another copy
data = data[args] # Memory: another copy
if weights is not None:
weights = weights[args]
del args
# Fill frequencies and errors
frequencies = np.zeros(bins.shape[0], dtype=dtype)
errors2 = np.zeros(bins.shape[0], dtype=dtype)
for xbin, bin in enumerate(bins):
start = np.searchsorted(data, bin[0], side="left")
stop = | np.searchsorted(data, bin[1], side="left") | numpy.searchsorted |
import numpy as np
from .helpers import scale, scale_clean
#from numba import jit
import pandas as pd
defs = {
'r9.4': {
'ed_params': {
'window_lengths': [3, 6], 'thresholds': [1.4, 1.1],
'peak_height': 0.2
}
},
'r9': {
'ed_params': {
'window_lengths': [6, 12], 'thresholds': [2.0, 1.1],
'peak_height': 1.2
}
},
'r9.5b': {
'ed_params': {
'window_lengths': [4, 5], 'thresholds': [1.4, 1.0],
'peak_height': 1
}
},
'r9.5': {
'ed_params': {
'window_lengths': [4, 6], 'thresholds': [1.4, 1.0],
'peak_height': 0.65
}
},
'rf': {
'ed_params': {
'window_lengths': [4, 6], 'thresholds': [1.4, 1.1], # [1.4, 1.1],
'peak_height': 1.2 # 1.2
}
}
}
def smooth(ser, sc):
return np.array(pd.Series(ser).rolling(sc, min_periods=1, center=True).mean())
def find_raw(raw, maxi=1000, safe=10):
m = raw
d2 = smooth( | np.sqrt((m[1:]-m[:-1])**2) | numpy.sqrt |
import os
import argparse
import numpy as np
import torch
import torch.optim as optim
from engine.dataloader import get_dataloader
from engine.retinanet import model
from engine.retinanet import coco_eval
from engine.log.saver import Saver
from tqdm import tqdm
from collections import deque
from engine.log import logger, summarise
assert torch.__version__.split('.')[0] == '1'
print('CUDA available: {}'.format(torch.cuda.is_available()))
class Trainer(object):
def __init__(self, config, img_dir, coco_json):
self.config = config
# Define Saver
self.saver = Saver(self.config)
# Define Tensorboard
if self.config.tensorboard:
self.summary = summarise.TensorboardSummary(self.saver.directory)
self.writer = self.summary.create_summary()
# Define Logger
self.getlogger = logger.get_logger(self.saver.directory)
self.logger = self.getlogger
# Define DataLoader
self.train_loader, self.n_train_img,\
self.val_set, self.val_loader, self.n_val_img, self.n_classes = get_dataloader(self.config, img_dir, coco_json)
# Define Network
if self.config.depth == 18:
self.retinanet = model.resnet18(num_classes=self.n_classes, pretrained=True)
elif self.config.depth == 34:
self.retinanet = model.resnet34(num_classes=self.n_classes, pretrained=True)
elif self.config.depth == 50:
self.retinanet = model.resnet50(num_classes=self.n_classes, pretrained=True)
elif self.config.depth == 101:
self.retinanet = model.resnet101(num_classes=self.n_classes, pretrained=True)
elif self.config.depth == 152:
self.retinanet = model.resnet152(num_classes=self.n_classes, pretrained=True)
else:
raise ValueError('Unsupported model depth, must be one of 18, 34, 50, 101, 152')
# Define Optimizer
self.optimizer = optim.Adam(self.retinanet.parameters(), lr=self.config.lr)
# Define lr_schduler
self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=3, verbose=True)
# Define loss
self.loss_hist = deque(maxlen=500)
# Define cuda
if torch.cuda.is_available():
self.retinanet = torch.nn.DataParallel(self.retinanet).cuda()
else:
raise ValueError('=> Cuda is not available. Check cuda')
# Define resume
self.best_f1_score = .0
if self.config.resume is not None:
self.retinanet = torch.load(self.config.resume)
self.retinanet.cuda()
# check model summary
# summary(self.retinanet, (3, 512, 512))
def train(self, epoch):
self.retinanet.train()
self.retinanet.module.freeze_bn()
epoch_loss = []
print(f'Num training images: {self.n_train_img}')
with tqdm(self.train_loader) as tbar:
for iter_num, data in enumerate(tbar):
self.optimizer.zero_grad()
img = data['img'].cuda().float()
annot = data['annot']
cls_loss, reg_loss = self.retinanet([img, annot])
cls_loss = cls_loss.mean()
reg_loss = reg_loss.mean()
loss = cls_loss + reg_loss
epoch_loss.append(float(loss))
self.loss_hist.append(float(loss))
if bool(loss == 0):
continue
loss.backward()
torch.nn.utils.clip_grad_norm_(self.retinanet.parameters(), 0.1)
self.optimizer.step()
if self.config.tensorboard:
self.writer.add_scalar('Train_Loss/classification_loss',
cls_loss,
iter_num + epoch*(len(self.train_loader)))
self.writer.add_scalar('Train_Loss/regression_loss',
reg_loss,
iter_num + epoch*(len(self.train_loader)))
self.writer.add_scalar('Train_Loss/total_loss',
np.mean(self.loss_hist),
iter_num + epoch*(len(self.train_loader)))
tbar.set_description(f'Epoch: {epoch} | '
f'Cls loss: {cls_loss:1.5f} | '
f'Reg loss: {reg_loss:1.5f} | '
f'Running loss: {np.mean(self.loss_hist):1.5f}')
del cls_loss, reg_loss
self.scheduler.step( | np.mean(epoch_loss) | numpy.mean |
'''Functions and scripts for machine learning training and
classification of photometry and spectra.'''
import os
import shutil
from functools import lru_cache
import itertools
import pickle
import argparse
import numpy as np
import requests
from astropy.table import Table
import astropy.units as u
from scipy.interpolate import interp1d
import matplotlib.pyplot as plt
import sdf.filter
import sdf.spectrum
import sdf.db
import sdf.photometry
from . import utils
from . import config as cfg
# routines related to photometry
def download_photometry(sdbid):
"""Get and return an sdf.Photometry object for a given sdbid.
Once retrieved, files are stored in photometry training directory.
Parameters
----------
sdbid : string
sdb id of desired target.
Returns
-------
sdf.Photometry object.
"""
fname = sdbid+'-rawphot.txt'
dir = cfg.training_dir+'photometry/photometry_files/'
try:
file = '/Users/grant/a-extra/sdb/masters/'+sdbid+'/public/'+fname
p = sdf.photometry.Photometry.read_sdb_file(file)
except FileNotFoundError:
try:
file = dir+fname
p = sdf.photometry.Photometry.read_sdb_file(file)
except FileNotFoundError:
r = requests.get('http://drgmk.com/sdb/seds/masters/'+
sdbid+'/public/'+fname,auth=(cfg.sdb_user,cfg.sdb_pass))
with open(dir+fname,'w') as f:
f.write(r.text)
p = sdf.photometry.Photometry.read_sdb_file(dir+fname)
# copy the file to the training dir
if not os.path.exists(dir+fname):
shutil.copyfile(file,dir+fname)
return p
@lru_cache()
def interpolator(colour_name,out_column='Teff'):
"""Return interpolator to get a value from the spectral type table.
Interpolation uses the colour table from Eric Mamajek's website.
Various derived columns are added so that as many input colours as
possible can be used.
Parameters
----------
colour_name : string
Name of the colour used for the interpolator.
out_column : string, optional
Name of column to retrieve, effective temperature by default.
Returns
-------
A scipy interp1d interpolator object.
"""
# assume eem means H_Ks when he says H_K
t = Table.read(os.path.dirname(os.path.abspath(__file__))+'/eem_colours.txt',
format='ascii',fill_values=[('...',0),('....',0),('.....',0)])
t['Rc-Ic'] = t['V-Ic'] - t['V-Rc']
t['Ks-W3'] = t['Ks-W1'] + t['W1-W3']
t['Ks-W4'] = t['Ks-W1'] + t['W1-W4']
t['W2-W3'] = t['W1-W3'] - t['W1-W2']
t['W3-W4'] = t['W1-W4'] - t['W1-W3']
# conversion from sdf filter names to eem ones
c = {'UJ_BJ':'U-B', 'BJ_VJ':'B-V', 'BT_VT':'Bt-Vt', 'VJ_RC':'V-Rc',
'VJ_IC':'V-Ic', 'RC_IC':'Rc-Ic',
'VJ_2MKS':'V-Ks', '2MJ_2MH':'J-H', '2MH_2MKS':'H-K',
'2MKS_WISE3P4':'Ks-W1', '2MKS_WISE12':'Ks-W3',
'2MKS_WISE22':'Ks-W4', 'WISE3P4_WISE4P6':'W1-W2',
'WISE3P4_WISE12':'W1-W3', 'WISE3P4_WISE22':'W1-W4',
'WISE4P6_WISE12':'W2-W3', 'WISE12_WISE22':'W3-W4',
'Teff':'Teff'}
if colour_name not in c.keys():
return None
# out of range interpolation yields cool and hot temperatures,
# otherwise zero colour (i.e. Vega)
if out_column == 'Teff':
fill = (30000.0,1500.0)
else:
fill = 0.0
ok = np.logical_and( t[c[colour_name]].mask == False,
t[c[out_column]].mask == False )
return interp1d(t[c[colour_name]][ok], t[c[out_column]][ok],
kind='linear',bounds_error=False,fill_value=fill)
class Colours(object):
"""Class to sort out colours for given photometry.
The goal is to return a list of colours for a given target, which
can then be used for the machine learning. Where the desired colours
don't exist they are either inferred from something close, or
interpolated based on an estimated effective temperature. Where very
little information exists the colours default to zero, meaning that
an object is by default assumed to be a star, and that a
classification is always possible.
There are various quirks of this approach.
- Stars bright enough to be detected at far-IR wavelengths are so
bright that no useful WISE W1/2 photometry exists. Therefore very
few stars with 'complete' photometry that can be derived without
interpolation exist.
Parameters
----------
phot : sdf.photometry.Photometry
Photometry object
wanted : list, optional
The colours we want returned.
extras : list, optional
Colours that may be useful in deriving what we want.
"""
def __init__(self,phot=None,
wanted=['2MJ_2MH','2MH_2MKS','2MKS_WISE3P4',
'WISE3P4_WISE4P6','WISE4P6_WISE12','WISE12_WISE22',
'KP_WAV100','WISE22_WAV100'],
extras=['2MKS_WISE12','2MKS_WISE22',
'WISE3P4_WISE12','WISE3P4_WISE22']):
self.wanted = wanted
if phot is not None:
# swap Read numbers in 2MASS for "plain" (2MR1KS -> 2MKS)
for i,f in enumerate(phot.filters):
if '2MR' in f:
phot.filters[i] = f[0:2]+f[4:]
self.extras_in = extras
ok = np.logical_and(phot.ignore == 0,phot.upperlim == 0)
self.in_names = phot.filters[ok]
self.in_values = phot.measurement[ok]
self.in_units = phot.unit[ok]
self.in_dict = {}
for key,val in zip(self.in_names,self.in_values):
self.in_dict[key] = val
# we'll fill these
self.colours = {}
self.extras = {}
self.filled = {}
# do it
self.fill_wav100()
self.fill_wise()
self.fill_kp()
self.fill_extras()
self.fill_colours()
self.fill_missing()
def fill_colours(self):
"""Fill missing colours that we want.
These are assumed to be sufficiently accurate, as opposed to
guessing or interpolating, that the values in the self.colours
dictionary are considered not to have been 'filled'.
"""
# if colours given
for i,name in enumerate(self.in_names):
if name in self.wanted:
self.colours[name] = self.in_values[i]
self.filled[name] = False
# if components of colours given
for name in self.wanted:
c = sdf.filter.Colour.get(name)
if c.filters[0] in self.in_names and c.filters[1] in self.in_names:
self.colours[name] = self.in_dict[c.filters[0]] - \
self.in_dict[c.filters[1]]
self.filled[name] = False
# attempt to fill BJ_VJ if not present, this doesn't count as filled
if 'BJ_VJ' in self.wanted and 'BJ_VJ' not in self.colours.keys():
# Tycho -> Johnson, 2002AJ....124.1670M
if 'BT' in self.in_names and 'VT' in self.in_names:
BT = self.in_dict['BT']
VT = self.in_dict['VT']
self.colours['BJ_VJ'] = (BT - VT) - 0.006 - \
0.1069*(BT - VT) + \
0.1459*(BT-VT)**2
self.filled['BJ_VJ'] = False
# or from APASS 1996AJ....111.1748F
elif 'GAPASS' in self.in_names and 'RAPASS' in self.in_names:
g_r = self.in_dict['GAPASS'] - self.in_dict['RAPASS']
VJ = self.in_dict['RAPASS'] + 0.44 * g_r - 0.02
BJ = VJ + 1.04 * g_r + 0.19
self.colours['BJ_VJ'] = BJ - VJ
self.filled['BJ_VJ'] = False
def fill_extras(self):
"""Fill missing extras from what we have, if possible."""
# if components of colours given
for name in self.extras_in:
c = sdf.filter.Colour.get(name)
if c.filters[0] in self.in_names and c.filters[1] in self.in_names:
self.extras[name] = self.in_dict[c.filters[0]] - \
self.in_dict[c.filters[1]]
def fill_missing(self):
"""Interpolate missing colours.
These are considered to have been 'filled', as they are guessed
(for zero colour) or interpolated.
"""
for name in self.wanted:
# if this key exists we already have the colour
if name in self.colours.keys():
continue
# zero colour at long wavelengths
elif name == 'WISE22_WAV100' or name == 'KP_WAV100':
self.colours[name] = 0.0
self.filled[name] = True
# else interpolate based on median Teff from what we have,
# setting zero colour if interpolation is not possible
else:
f = interpolator('Teff',name)
med_temp = self.med_temp()
self.filled[name] = True
if np.isfinite(med_temp):
self.colours[name] = f( med_temp ).tolist() # a float
else:
self.colours[name] = 0.0
def sorted_colours(self):
"""Return colours sorted by mean wavelength."""
names = list(self.colours.keys())
waves = []
for c in names:
col = sdf.filter.Colour.get(c)
waves.append( col.mean_wavelength )
srt = np.argsort(waves)
cols = []
for i in srt:
cols.append(self.colours[names[i]])
if not np.all(np.isfinite(cols)):
print("Not all colours finite ({})".format(cols))
return None
if len(cols) != len(self.wanted):
print("Didn't get all wanted colours")
return None
return cols
def med_temp(self):
"""Return the median temperature for defined colours."""
temp = []
for key in self.extras.keys():
f = interpolator(key)
if f is not None:
temp.append( f(self.extras[key]) )
for key in self.colours.keys():
f = interpolator(key)
if f is not None and not self.filled[key]:
temp.append( f(self.colours[key]) )
if len(temp) > 0:
med_t = np.nanmedian(temp)
else:
med_t = np.nan
return med_t
def fill_wise(self):
"""Fill WISE mags from Spitzer and AKARI.
These are assumed to be sufficiently accurate that they are
considered not to have been 'filled'.
"""
# IRAC fluxes in uJy
if 'WISE3P4' not in self.in_names and 'IRAC3P6' in self.in_names:
f = sdf.filter.Filter.get('IRAC3P6')
mag36 = f.flux2mag(self.in_dict['IRAC3P6']/1e6)
self.in_names = np.append(self.in_names,'WISE3P4')
self.in_values = np.append(self.in_values,mag36)
self.in_dict['WISE3P4'] = mag36
self.filled['WISE3P4'] = False
if 'WISE4P6' not in self.in_names and 'IRAC4P5' in self.in_names:
f = sdf.filter.Filter.get('IRAC4P5')
mag45 = f.flux2mag(self.in_dict['IRAC4P5']/1e6)
self.in_names = np.append(self.in_names,'WISE4P6')
self.in_values = np.append(self.in_values,mag45)
self.in_dict['WISE4P6'] = mag45
self.filled['WISE4P6'] = False
# AKARI fluxes in Jy
if 'WISE12' not in self.in_names and 'AKARI9' in self.in_names:
f = sdf.filter.Filter.get('AKARI9')
mag9 = f.flux2mag(self.in_dict['AKARI9'])
self.in_names = np.append(self.in_names,'WISE12')
self.in_values = np.append(self.in_values,mag9)
self.in_dict['WISE12'] = mag9
self.filled['WISE12'] = False
# MIPS 24 fluxes in uJy
if 'WISE22' not in self.in_names and 'MIPS24' in self.in_names:
f = sdf.filter.Filter.get('MIPS24')
mag24 = f.flux2mag(self.in_dict['MIPS24']/1e6)
self.in_names = np.append(self.in_names,'WISE22')
self.in_values = np.append(self.in_values,mag24)
self.in_dict['WISE22'] = mag24
self.filled['WISE22'] = False
# AKARI fluxes in Jy
if 'WISE22' not in self.in_names and 'AKARI18' in self.in_names:
f = sdf.filter.Filter.get('AKARI18')
mag18 = f.flux2mag(self.in_dict['AKARI18'])
self.in_names = np.append(self.in_names,'WISE22')
self.in_values = np.append(self.in_values,mag18)
self.in_dict['WISE22'] = mag18
self.filled['WISE22'] = False
# IRAS fluxes in Jy
if 'WISE12' not in self.in_names and 'IRAS12' in self.in_names:
f = sdf.filter.Filter.get('IRAS12')
mag12 = f.flux2mag(self.in_dict['IRAS12'])
self.in_names = np.append(self.in_names,'WISE12')
self.in_values = np.append(self.in_values,mag12)
self.in_dict['WISE12'] = mag12
self.filled['WISE12'] = False
# IRAS fluxes in Jy
if 'WISE22' not in self.in_names and 'IRAS25' in self.in_names:
f = sdf.filter.Filter.get('IRAS25')
mag25 = f.flux2mag(self.in_dict['IRAS25'])
self.in_names = np.append(self.in_names,'WISE22')
self.in_values = np.append(self.in_values,mag25)
self.in_dict['WISE22'] = mag25
self.filled['WISE22'] = False
def fill_wav100(self,bands=['IRAS60','IRAS100','MIPS70','PACS70','PACS100']):
"""Derive a WAV100 magnitude, using the given bands.
Parameters
----------
bands : list, optional
Bands that can be used to derive the WAV100 magnitude.
"""
f = []
for i,name in enumerate(self.in_names):
ok = np.where(name == np.array(bands))[0]
if len(ok) > 0:
filt = sdf.filter.Filter.get(name)
if self.in_values[i] <= 0:
continue
flux_jy = (self.in_values[i]*self.in_units[i]).to('Jy').value
wave = np.linspace(25,150,50)
_,cc = filt.synthphot(
sdf.spectrum.ModelSpectrum(wavelength=wave,
fnujy_sr=1/wave**2))
f.append( filt.flux2mag(flux_jy) )
if len(f) > 0:
wav100 = np.median(f)
self.in_names = np.append(self.in_names,'WAV100')
self.in_values = np.append(self.in_values,wav100)
self.in_dict['WAV100'] = wav100
def fill_kp(self,bands=['VJ','VT','HP','2MJ','2MH','2MKS','WISE3P4']):
"""Derive a 'Kepler' magnitude using the given bands.
This photometry is to have an optical magnitude to create the
KP-WAV100 colour. KP is chosen because no observed photometry
from this band exists (in sdb).
Parameters
----------
bands : list, optional
Bands that can be used to derive the KP magnitude.
"""
if 'KP' not in self.in_dict.keys():
for f in bands:
if f in self.in_dict.keys():
self.in_names = np.append(self.in_names,'KP')
self.in_values = np.append(self.in_values,self.in_dict[f])
self.in_dict['KP'] = self.in_dict[f]
def skipped(self):
"""Return a boolean indicating if this object should be skipped.
Conditions to be skipped are:
- no effective temperature estimate
- more than two 'filled' colours (>1 missing phot)
"""
if not np.isfinite(self.med_temp()):
return True
elif np.sum(list(self.filled.values())) > 2:
return True
else:
return False
def get_data(files):
"""Get and prepare input data given a list of label files.
Files should have sdbid and label columns. The photometry files are
obtained by download_data. Whether a file should be skipped is
decided in colours.skipped.
Parameters
----------
files : list
List of csv files, first column sdbid name, second label
Returns
-------
A tuple of:
- data [n_data,n_colurs]
- one hot array of labels [n_data,n_classes]
- sdbids [n_data]
- skip [n_data] (whether this file should be skipped)
- label names [n_classes]
"""
sdbids = []
data = []
labels = []
skip = []
# go through all files to get labels
label_names = | np.array([]) | numpy.array |
#///////////////////////////////////////////////////////////////#
#///////////////////////////////////////////////////////////////#
#%%
# Import Libraries.
# Torch.
import torch
import torchvision
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
# Torchvision.
import torchvision.transforms as transforms
from torchvision import transforms, datasets, models
# Numpy, Matplotlib and other utility functions.
import numpy as np
import matplotlib.pyplot as plt
import time
import copy
import os
#///////////////////////////////////////////////////////////////#
#///////////////////////////////////////////////////////////////#
#%%
# Helpher Functions.
# Imshow for Tensor.
def imshow(img, title=None):
img = img.numpy().transpose((1, 2, 0))
mean = np.array([0.5, 0.5, 0.5])
std = | np.array([0.5, 0.5, 0.5]) | numpy.array |
import unittest
import pytest
import xarray as xr
import pandas as pd
from pywatts.core.exceptions.input_not_available import InputNotAvailable
from pywatts.modules import RmseCalculator
import numpy as np
class TestRMSECalculator(unittest.TestCase):
def setUp(self) -> None:
self.rmse_calculator = RmseCalculator()
def tearDown(self) -> None:
self.rmse_calculator = None
def test_get_params(self):
self.assertEqual(self.rmse_calculator.get_params(),
{'offset': 0, 'rolling': False, 'window': 24})
def test_set_params(self):
self.rmse_calculator.set_params(offset=24, rolling=True, window=2)
self.assertEqual(self.rmse_calculator.get_params(),
{'offset': 24, 'rolling': True, 'window': 2})
def test_transform_rolling(self):
self.rmse_calculator.set_params(rolling=True, window=2)
time = pd.to_datetime(['2015-06-03 00:00:00', '2015-06-03 01:00:00',
'2015-06-03 02:00:00', '2015-06-03 03:00:00',
'2015-06-03 04:00:00'])
test_data = xr.Dataset({"testCol": ("time", xr.DataArray([-2, -1, 0, 1, 2]).data),
"predictCol1": ("time", xr.DataArray([2, -3, 3, 1, -2]).data),
"predictCol2": ("time", xr.DataArray([4, 4, 3, -2, 1]).data), "time": time})
test_result = self.rmse_calculator.transform(y=test_data['testCol'], gt=test_data['testCol'],
pred1=test_data['predictCol1'],
pred2=test_data['predictCol2'])
expected_result = xr.DataArray(np.array([[np.nan, np.nan, np.nan],
[0.0, np.sqrt(10), np.sqrt(30.5)],
[0.0, np.sqrt(6.5), | np.sqrt(17) | numpy.sqrt |
# suppressing messages only works if set before tensorflow is imported
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import tensorx as tx
import numpy as np
import pytest
import tensorflow as tf
def test_input_spec():
x = tx.Input()
assert x.shape.as_list() == [None, None]
x = tx.Input(n_units=1, shape=None)
assert x.shape.as_list() == [None, 1]
# n_units does not match shape
with pytest.raises(ValueError):
tx.Input(n_units=1, shape=[])
x = tx.Input(n_units=1, shape=[1])
assert x.shape.as_list() == [1]
assert tx.tensor_equal(x(), tf.zeros([1]))
with pytest.raises(ValueError):
tx.Input(n_units=1, shape=[None, 2])
with pytest.raises(ValueError):
tx.Input(n_units=0, shape=[None, 1])
x = tx.Input(n_units=2, shape=[None, None, 2])
assert x.n_units == 2
assert x.shape.as_list() == [None, None, 2]
assert tx.tensor_equal(x(), tf.zeros([1, 1, 2]))
value = tf.ones([2, 2])
x = tx.Input(value)
assert x.shape.as_list() == [None, 2]
with pytest.raises(ValueError):
tx.Input(value, n_units=3)
with pytest.raises(ValueError):
tx.Input(value, shape=[None])
with pytest.raises(ValueError):
tx.Input(value, shape=[None, 3])
with pytest.raises(ValueError):
tx.Input(value, shape=[None, None, 2])
x = tx.Input(value, shape=[None, 2])
assert x.shape.as_list() == [None, 2]
x = tx.Input(value)
assert x.dtype == value.dtype
assert x.dtype == tf.float32
x = tx.Input(value, dtype=tf.int32)
assert x.dtype == tf.int32
assert x().dtype == tf.int32
x = tx.Input(value, dtype=tf.int32, cast=False)
with pytest.raises(TypeError):
x.value = value
x = tx.Input(value, n_active=2, n_units=10)
assert x.dtype == tf.int64
assert isinstance(x(), tf.SparseTensor)
with pytest.raises(ValueError):
# [2,2] not compatible with [None,3]
tx.Input(value, n_active=3, n_units=10)
def test_input_config():
in1 = tx.Input(init_value=tf.ones([2, 2]), n_units=2)
cfg1 = in1.config
in2 = cfg1()
assert tx.tensor_equal(in1(), in2())
def test_input_value():
inputs = tx.Input(n_units=4, dtype=tf.int32, constant=False)
assert tx.tensor_equal(inputs.value, tf.zeros([1, 4], dtype=tf.int32))
with pytest.raises(ValueError):
inputs.value = np.ones([2, 3], dtype=np.int32)
inputs.value = np.ones([2, 4], dtype=np.int32)
assert inputs.value is not None
assert inputs() is not None
assert inputs().dtype == tf.int32
# test sparse input
inputs = tx.Input(n_units=4, n_active=2, dtype=tf.int64, constant=False)
assert tx.tensor_equal(inputs.value, tf.zeros([0, 2], dtype=tf.int64))
with pytest.raises(ValueError) as ve:
inputs.value = [[0, 2, 2]]
assert "Invalid shape" in str(ve)
inputs.value = [[0, 2]]
# create an equivalent sparse input
sp_input = inputs()
assert isinstance(sp_input, tf.SparseTensor)
inputs2 = tx.Input(n_units=4, init_value=sp_input)
dense_value = tf.sparse.to_dense(inputs())
dense_value2 = tf.sparse.to_dense(inputs2())
expected = tf.constant([[1, 0, 1, 0]], dtype=np.int64)
assert tx.tensor_equal(expected, dense_value)
assert tx.tensor_equal(dense_value, dense_value2)
def test_input_compile():
inputs = tx.Input(n_units=4, dtype=tf.int32, constant=False)
fn = tf.function()(inputs.__call__)
assert tx.tensor_equal(fn(), tf.zeros([1, 4], dtype=tf.int32))
def test_input_3d():
# we either create a 3d input or specify the shape
data = np.ones([2, 2, 2], dtype=np.float32)
x = tx.Input(shape=[None, None, 2], dtype=tf.float32, n_units=2)
x.value = data
x.value = x() * 2
assert tx.tensor_equal(data * 2, x())
x2 = tx.Input(data)
assert x2.n_units == np.shape(data)[-1]
assert x2.shape[-1] == np.shape(data)[-1]
x2.value = x2() * 2
assert tx.tensor_equal(data * 2, x2())
with pytest.raises(ValueError, match="Invalid shape"):
x3 = tx.Input(n_units=2)
x3.value = data
pytest.fail("Value Error Expected: invalid shape for value set")
def test_dynamic_input_graph():
"""
When we freeze the graph function with a dynamic input,
the function includes a variable value read operation, that
reads from the variable defined in the Input layer
"""
x = tx.Input(tf.zeros([2, 2]), n_units=2, constant=False)
y = tx.Linear(x, 2, add_bias=False)
graph_function = y.as_function()
out1 = graph_function()
assert tx.tensor_equal(out1, tf.zeros([2, 2]))
x.value = tf.ones([2, 2])
out2 = graph_function()
assert tx.tensor_equal(out2, tf.matmul(tf.ones([2, 2]), y.weights))
assert not tx.tensor_equal(out1, out2)
def test_activation():
inputs = tx.Input(init_value=tf.ones([2, 2]), n_units=2)
output = tx.Activation(inputs, tf.sigmoid)
assert tx.shape_equal(inputs.shape, output.shape)
def test_shared_state():
inputs = tf.ones([2, 4])
l1 = tx.Linear(inputs, 8)
l2 = tx.Linear(inputs, 8, share_state_with=l1)
proto = tx.Linear.config(n_units=8, share_state_with=l1)
l3 = proto(inputs)
assert l1.weights is l2.weights
assert l1.bias is l2.bias
assert l1.weights is l3.weights
assert l1.bias is l3.bias
def test_mul():
# also tests graphs with constants
inputs = tx.Constant(tf.constant(2), dtype=tf.float64)
inputs2 = inputs * 2
assert tx.tensor_equal(inputs2(), inputs() * 2)
inputs2_fn = tf.function(inputs2.__call__)
assert inputs2_fn() == inputs2()
def test_linear_function():
inputs = tx.Constant(tf.ones([2, 4]), dtype=tf.float64)
linear = tx.Linear(inputs, n_units=8, dtype=tf.float64)
fn = tf.function(linear.__call__)
assert tx.tensor_equal(fn(), linear())
def test_linear():
inputs = tx.Constant(tf.ones([2, 4]), dtype=tf.float64)
inputs2 = inputs * 2
linear = tx.Linear(inputs, n_units=8, dtype=tf.float64)
w = linear.weights
b = linear.bias
assert w.shape == [4, 8]
assert b.shape == [8]
assert len(linear.trainable_variables) == 2
t1 = linear()
t2 = linear()
assert tx.tensor_equal(t1, t2)
linear2 = tx.Linear(linear.inputs[0], 8, share_state_with=linear, dtype=tf.float64)
t3 = linear2()
assert tx.tensor_equal(t1, t3)
linear = tx.Linear(inputs, 8, dtype=tf.float64)
linear2 = linear.reuse_with(inputs2)
assert linear.weights is linear2.weights
assert linear.bias is linear2.bias
assert tx.tensor_equal(linear() * 2, linear2())
def test_linear_rank3():
val = tf.constant([[[1], [1]], [[2], [2]]])
x1 = tx.Input(val, dtype=tf.float32)
x2 = tx.Transpose(x1)
assert val.shape[1:] == x1.shape[1:]
x1_flat = tx.Reshape(x1, [-1, 1])
linear1 = tx.Linear(x1, n_units=2)
linear2 = tx.Linear(x2,
weights_shape=[2, 1],
weights=linear1.weights,
transpose_weights=True)
# we cant do this because it changes the definition
# of the layer (n_units etc)
with pytest.raises(ValueError):
linear1.reuse_with(x2, transpose_weights=True)
pytest.fail("can't reuse with transpose weights while changing the layer definition")
linear_flat = linear1.reuse_with(x1_flat, shape=(4, 2))
x1_tensor = x1()
new_shape = x1_tensor.shape[:-1] + [2]
linear_flat = tx.Reshape(linear_flat, new_shape)
assert tx.tensor_equal(linear1(), linear_flat())
assert tx.tensor_equal(tf.shape(linear2()), [1, 2, 1])
def test_constant_shape():
tensor = tf.ones([3, 3])
const_layer = tx.Constant(tensor)
assert const_layer.shape == tensor.shape
def test_transpose():
tensor = tf.ones([3, 3])
trans_tensor = tf.transpose(tensor)
trans_layer = tx.Transpose(tensor, n_units=3)
assert trans_layer.input.shape == [3, 3]
assert trans_layer.shape == trans_tensor.shape
tensor = tf.ones([2, 3, 4])
perm = [2, 0, 1]
trans_tensor = tf.transpose(tensor, perm)
trans_layer = tx.Transpose(tensor, perm)
assert trans_layer.input.n_units == tensor.shape[-1]
assert trans_layer.shape == trans_tensor.shape
assert trans_layer.n_units == tensor.shape[perm[-1]]
inputs = tx.Input(shape=tf.TensorShape([None, 3]))
trans = tx.Transpose(inputs)
assert trans.shape[-1] is None
assert trans.shape[0] == 3
def test_reshape_shape():
x = tf.reshape(tf.range(9), [3, 3, 1])
x = tx.Input(x, dtype=tf.float32)
flat = tx.Reshape(x, [-1, 1])
assert flat.shape[0] is None
assert flat.shape[-1] == 1
x = tx.Input(x, shape=[3, 3, 1], dtype=tf.float32)
print(x.shape)
flat = tx.Reshape(x, [-1, 1])
print(flat.shape)
def test_transpose_reshape():
x = tf.reshape(tf.range(9), [3, 3])
x2 = tx.Reshape(tf.range(9), [3, 3])
assert tx.tensor_equal(x2(), x)
assert tx.tensor_equal(x2.compute(tf.range(9)), x)
t = tf.transpose(x)
y = tx.Transpose(t)
assert tx.tensor_equal(y(), x)
assert tx.tensor_equal(y.compute(x), t)
x = tf.reshape(tf.ones([18]), [-1, 3, 2])
x2 = tx.Reshape(tf.ones([18]), [-1, 3, 2])
assert x.shape == [3, 3, 2]
assert x.shape == x2.shape
def test_mul_shape():
x = tx.Input(n_units=3)
m = x * 2
assert m.shape[0] is None
assert m.shape[-1] is 3
t = tx.Transpose(x)
assert t.shape[-1] is None
t = tx.Transpose(x, n_units=3)
assert t.shape == [3, 3]
m = t * 2
assert m.shape == [3, 3]
x = tx.Input(n_units=3) # [None,3]
t = tx.Transpose(x) # [None,None]
assert t.shape[0] == 3
assert t.shape[-1] is None
m = t * 2 # [None,None]
# TensorShape([3,None]) != TensorShape([3,None])
# because we don't know what None is
assert m.shape[0] == 3
assert m.shape[-1] is None
def test_module_shape():
x = tx.Input(n_units=3)
t = tx.Transpose(x, n_units=3)
mul = t * 2
assert mul.shape == [3, 3]
m = tx.Module(output=mul, inputs=x)
assert m.n_units == 3
m()
def test_wrap_shape():
x = tx.Input(n_units=3)
t = tx.Transpose(x, n_units=3)
assert t.shape[-1] == 3
w = tx.Wrap(t, wrap_fn=lambda layer: layer * 2)
assert w.shape == [3, 3]
def test_wrap_transpose():
tensor = tf.reshape(tf.range(9), [3, 3])
t = tf.transpose(tensor)
t_layer = tx.Transpose(t, n_units=3)
assert t_layer.shape == (3, 3)
mul2 = tx.Wrap(t_layer, wrap_fn=lambda layer: layer * 2)
mul2_2 = mul2.reuse_with(tensor)
assert tx.tensor_equal(mul2_2(), t * 2)
assert tx.tensor_equal(mul2(tensor), t * 2)
assert tx.tensor_equal(mul2(t), mul2())
assert tx.tensor_equal(mul2.compute(t), mul2())
assert tx.tensor_equal(mul2.compute(t), tf.transpose(t) * 2)
assert tx.tensor_equal(t_layer.compute(t), tensor)
assert tx.tensor_equal(mul2_2.compute(tensor), mul2_2())
def test_variable_layer():
input_layer = tx.Input([[1]], n_units=1, dtype=tf.float32)
var_layer = tx.VariableLayer(input_layer, dtype=tf.float32)
init_value = var_layer.variable.value()
after_update = var_layer()
assert not tx.tensor_equal(init_value, after_update)
assert tx.tensor_equal(after_update, var_layer.variable.value())
def test_variable_init_from_input():
input_layer = tx.Input(n_units=1, constant=False)
layer_once = tx.VariableLayer(input_layer, update_once=True)
layer_var = tx.VariableLayer(input_layer, update_once=False)
layer_once.reuse_with(init_from_input=False)
data1 = np.array([[1]])
data2 = np.array([[2]])
data3 = np.array([[3]])
input_layer.value = data1
# counter is a tf.Variable
assert layer_once.counter.value() == 0
input_layer.value = data2
y1 = layer_once()
assert layer_once.counter.value() == 1
assert tx.tensor_equal(layer_once.variable.value(), y1)
input_layer.value = data3
y2 = layer_once()
assert layer_once.counter.value() == 1
assert tx.tensor_equal(y1, y2)
assert tx.tensor_equal(y1, layer_once.variable.value())
# dynamic var layer
input_layer.value = data1
assert layer_var.counter.value() == 0
y1 = layer_var()
assert layer_var.counter.value() == 1
assert tx.tensor_equal(layer_var.variable.value(), y1)
input_layer.value = data2
y2 = layer_var()
assert layer_var.counter.value() == 2
assert not tx.tensor_equal(y1, y2)
def test_variable_layer_reuse():
input_layer = tx.Input([[1]], n_units=1, dtype=tf.float32)
input_layer2 = tx.Input([[1], [2]], n_units=1, dtype=tf.float32)
var1 = tx.VariableLayer(shape=[2, 1])
var2 = var1.reuse_with(input_layer)
var3 = var1.reuse_with(input_layer2)
v0 = var1()
v1 = var2()
assert not tx.tensor_equal(v0, v1)
# v0 inner variable changed when we evaluate v1
v2 = var1()
assert not tx.tensor_equal(v0, v1)
v3 = var3()
assert not tx.tensor_equal(v2, v3)
v4 = var1()
assert tx.tensor_equal(v3, v4)
# variable batch dimension is dynamic its shape will be different
assert not tx.same_shape(v4, v1)
assert tx.same_shape(v2, v1)
def test_standalone_variable_layer():
var_layer = tx.VariableLayer(shape=[4])
assert tx.tensor_equal(np.zeros([4], dtype=np.float32), var_layer())
assert not tx.tensor_equal(np.zeros([4]), var_layer())
assert tx.tensor_equal(tf.zeros([4]), var_layer())
def test_merge_add_shape():
x1 = tx.Input([[2.]], n_units=1, name="x1")
x2 = tx.Input([[2.]], n_units=1, name="x2")
add = tx.Add(x1, x2)
assert len(add.shape) == 2
assert add.shape[-1] == 1
assert add.shape[0] is None
def test_module_reuse_order():
x1 = tx.Input([[2.]], n_units=1, name="x1")
x2 = tx.Input([[2.]], n_units=1, name="x2")
x3 = tx.Input([[1.]], n_units=1, name="x3")
h = tx.Add(x2, x3)
y = tx.Add(x1, h)
module = tx.Module(inputs=[x1, x2, x3], output=y)
x1_ = tx.Constant([[2.]], name="x1b")
x2_ = tx.Constant([[2.]], name="x2b")
m2 = module.reuse_with(x1_, x2_)
m1 = module()
m2 = m2()
assert tx.tensor_equal(m1, m2)
def test_attention_rnn_shape():
""" test attention and rnn layers integration with shape inference
"""
x1 = tx.Input(tf.ones([1, 2, 3]), n_units=3, name="x1")
rnn1 = tx.RNN(x1, cell_config=tx.LSTMCell.config(n_units=4), n_units=4, stateful=False)
att = tx.MHAttention(rnn1, rnn1, rnn1, n_units=3)
rnn1_res = rnn1()
att_res = att()
assert rnn1.n_units == 4
assert rnn1.n_units == rnn1.cell.n_units
assert tx.shape_equal(rnn1.shape[:-1], att.shape[:-1])
assert att.shape[-1] == att.n_units
assert tx.shape_equal(rnn1_res.shape[1:], rnn1.shape[1:])
assert tx.shape_equal(att_res.shape[1:], att.shape[1:])
def test_module_rnn():
""" Module + RNN integration
"""
# test wrapping module around RNN because it has input dependencies that might not be given in the constructor
x1 = tx.Input(tf.ones([1, 2, 3]), n_units=3, name="x1")
x2 = tx.Input(tf.ones([1, 2, 3]), n_units=3, name="x2")
rnn1 = tx.RNN(x1, cell_config=tx.LSTMCell.config(n_units=4), n_units=4, stateful=False)
rnn2 = tx.RNN(x1, cell_config=tx.LSTMCell.config(n_units=4), n_units=4, stateful=False)
out = tx.Concat(rnn1, rnn2)
# add previous state as a dependency to a module
m = tx.Module(inputs=x1, output=out,
dependencies=rnn1.previous_state + rnn2.previous_state)
m2 = m.reuse_with(x2)
var_layers = set()
for node in m2.graph.dependency_iter():
if isinstance(node, tx.VariableLayer):
var_layers.add(node)
assert var_layers == set(rnn1.previous_state + rnn2.previous_state)
assert tx.tensor_equal(m(), m2())
def test_module_with_attention():
""" Module + Attention integration
This also tests Graph indirectly to check if we can add layers
whose input layers are the same object (e.g. in self-attention)
"""
x1 = tx.Input(tf.ones([1, 2, 3]), n_units=3, name="x1")
rnn1 = tx.RNN(x1, cell_config=tx.LSTMCell.config(n_units=4), n_units=4, stateful=False)
att = tx.MHAttention(rnn1, rnn1, rnn1, n_units=3)
m = tx.Module(inputs=x1, output=att, dependencies=rnn1.previous_state)
g = tx.Graph.build(inputs=x1, outputs=m, add_missing_inputs=True)
fn = g.as_function(ord_inputs=x1, ord_outputs=m)
# this returns a tuple
out1 = g.compute(tf.ones([1, 2, 3]))
# this returns the function result
out2 = fn(tf.ones([1, 2, 3]))
assert tx.tensor_equal(out1[0], out2)
def test_module():
l1 = tx.Input([[1]], n_units=1, dtype=tf.float32)
l2 = tx.Input([[1]], n_units=1, dtype=tf.float32)
l3 = tx.layer(n_units=1)(lambda x1, x2: tf.add(x1, x2))(l1, l2)
l4 = tx.layer(n_units=1)(lambda x1, x2: tf.add(x1, x2))(l1, l2)
l5 = tx.Linear(l4, 1)
in1 = tx.Input([[1]], n_units=1, dtype=tf.float32)
l7 = tx.layer(n_units=1)(lambda x1, x2: tf.add(x1, x2))(l3, in1)
l8 = tx.layer(n_units=1)(lambda x1, x2: tf.add(x1, x2))(l7, l5)
in2 = tx.Input([[1]], n_units=1, dtype=tf.float32, constant=False)
in3 = tx.Input([[1]], n_units=1, dtype=tf.float32)
m = tx.Module([l1, l2, in1], l8)
with tf.name_scope("module_reuse"):
m2 = m.reuse_with(in2, in3, in1)
assert tx.tensor_equal(m(), m2())
in2.value = [[3]]
assert not tx.tensor_equal(m(), m2())
def test_rnn_cell():
n_inputs = 4
n_hidden = 2
batch_size = 2
x = tx.Input(init_value=tf.ones([batch_size, n_inputs]), constant=False)
rnn1 = tx.RNNCell(x, n_hidden)
assert rnn1.shape[0] == x.shape[0]
assert rnn1.shape[-1] == rnn1.n_units
state = rnn1.state
state = state[0]()
rnn_2 = rnn1.reuse_with(x, state)
rnn_3 = rnn1.reuse_with(x)
with pytest.raises(TypeError):
tx.RNNCell(x, n_hidden, share_state_with=x)
pytest.fail("Type Error Expected: inputs cannot share state with RNNCell")
res1 = rnn1()
res2 = rnn_2()
res3 = rnn_3()
assert (batch_size, n_hidden) == np.shape(res1)
assert tx.tensor_equal(res1, res3)
assert not tx.tensor_equal(res1, res2)
def test_rnn_layer_config():
x1 = tx.Input(init_value=tf.ones([2, 2]), n_units=2)
x_config = x1.config
x2 = x_config()
assert tx.tensor_equal(x1(), x2())
rnn_cell = tx.RNNCell(input_layer=x1, n_units=3)
rnn_proto = rnn_cell.config
rnn_cell2 = rnn_proto(x1)
assert tx.same_shape(rnn_cell(), rnn_cell2())
assert not tx.tensor_equal(rnn_cell(), rnn_cell2())
def test_gru_cell_module():
n_inputs = 4
n_hidden = 2
batch_size = 2
data = tf.ones([batch_size, 4])
inputs = tx.Input(init_value=data, n_units=n_inputs, dtype=tf.float32)
rnn_1 = tx.GRUCell(inputs, n_hidden)
fn = rnn_1.as_function(compile=True)
fn()
# rnn_2 = rnn_1.reuse_with(inputs, rnn_1)
#
# rnn_3 = rnn_1.reuse_with(inputs, tx.GRUCell.zero_state(rnn_1.n_units))
#
# res1 = rnn_1()
# res2 = rnn_2()
# res3 = rnn_3()
#
# assert (batch_size, n_hidden) == np.shape(res1)
# assert tx.tensor_equal(res1, res3)
# assert not tx.tensor_equal(res1, res2)
def test_rnn_cell_graph():
n_inputs = 4
n_hidden = 2
batch_size = 2
data1 = tf.ones([batch_size, n_inputs])
inputs = tx.Input(data1)
rnn1 = tx.RNNCell(inputs, n_hidden)
# if we use missing_inputs=True, extra inputs might be added
with pytest.raises(ValueError):
tx.Graph.build(inputs=inputs,
outputs=rnn1,
add_missing_inputs=False)
pytest.fail("Value Error Expected: missing inputs")
g = tx.Graph.build(inputs=inputs,
outputs=rnn1,
add_missing_inputs=True)
f = g.as_function(ord_inputs=inputs)
f(data1)
def test_rnn_cell_drop():
n_hidden = 4
inputs1 = tx.Input(np.ones([2, 100]), dtype=tf.float32)
inputs2 = tx.Input(np.ones([2, 100]), dtype=tf.float32)
with tf.name_scope("wtf"):
rnn1 = tx.RNNCell(inputs1, n_hidden,
x_dropout=0.5,
r_dropout=0.5,
u_dropconnect=0.5,
w_dropconnect=0.5,
regularized=True
)
rnn2 = rnn1.reuse_with(inputs2, rnn1)
rnn3 = rnn1.reuse_with(inputs2, rnn1)
rnn4 = rnn1.reuse_with(inputs2, None, regularized=False)
rnn5 = rnn4.reuse_with(inputs2, None, regularized=True)
r1, r2, r3, r4, r5 = rnn1(), rnn2(), rnn3(), rnn4(), rnn5()
# w is a linear layer from the input but a regularized layer applies dropout to the input, so we have a dropout
# in between
# without a shared state object, we couldn't rewire graphs, in the case of non-eager we can share a tensor
# that is already wired with something (it takes the shape of the input of one layer and creates a mask tensor
# shared across dropout instances
# Linear layers should have shared states as well, in this case sharing the weights
# dropout_state1 = rnn1.w.input_layers[0].layer_state
# dropout_state2 = rnn2.w.input_layers[0].layer_state
# dropout_state3 = rnn3.w.input_layers[0].layer_state
# mask1, mask2, mask3 = dropout_state1.mask, dropout_state2.mask, dropout_state3
assert tx.tensor_equal(r2, r3)
assert not tx.tensor_equal(r2, r4)
assert not tx.tensor_equal(r4, r5)
assert rnn1.dropout_locked
assert rnn2.dropout_locked
assert hasattr(rnn1, "w")
assert hasattr(rnn2, "w")
w1: tx.Layer = getattr(rnn1, "w")
w2: tx.Layer = getattr(rnn2, "w")
assert isinstance(w1, tx.DropConnect)
state1, state2 = w1.layer_state, w2.layer_state
assert hasattr(state1, "weight_mask")
assert hasattr(state2, "weight_mask")
# dropout locked == true
mask1 = getattr(state1, "weight_mask")
mask2 = getattr(state2, "weight_mask")
assert tx.tensor_equal(mask1, mask2)
def test_to_sparse():
inputs = tx.Input(init_value=tf.ones([2, 100]))
linear = tx.Linear(inputs, n_units=100)
relu = tx.Activation(linear, tx.relu)
sparse = tx.ToSparse(relu)
assert tx.shape_equal(sparse.shape, linear.shape)
assert tx.shape_equal(sparse.shape, relu.shape)
def test_gate():
inputs = tx.Input(init_value=tf.ones([2, 3]))
linear = tx.Linear(inputs, n_units=4)
nop = tx.Activation(linear, fn=tx.identity)
gate_w = tx.Linear(linear, n_units=4, add_bias=True)
gate1 = tx.Gate(linear, gate_w)
gate2 = gate1.reuse_with(nop)
assert tx.shape_equal(gate1.shape, gate2.shape)
r1 = gate1()
r2 = gate2()
assert tx.tensor_equal(r1, r2)
def test_coupled_gate():
vocab_size = 4
n_features = 3
seq_size = 2
inputs = tx.Input(init_value=np.array([[2, 0], [1, 2]]),
n_units=seq_size,
dtype=tf.int32,
constant=True)
features1 = tx.Lookup(inputs, seq_size, embedding_shape=[vocab_size, n_features]).as_concat()
features2 = tx.Lookup(inputs, seq_size, embedding_shape=[vocab_size, n_features]).as_concat()
gate_w = tx.Linear(features1, seq_size, add_bias=True)
coupled_gate = tx.CoupledGate(features1, features2, gate_w)
sp_features1 = tx.ToSparse(features1)
assert tx.tensor_equal(tf.sparse.to_dense(sp_features1()), features1())
sp_gate = tx.CoupledGate(sp_features1, features2, gate_w)
print(sp_gate())
print(sp_gate.shape)
# coupled_gate2 = coupled_gate.reuse_with(sp_features1, features2)
r1 = coupled_gate()
# r2 = coupled_gate2()
# assert tx.tensor_equal(r1, r2)
def test_module_gate():
""" Module + Gate Integration
"""
x1 = tx.Input([[1, 1, 1, 1]], n_units=4, dtype=tf.float32)
x2 = tx.Input([[1, 1]], n_units=2, dtype=tf.float32)
x1 = tx.Add(x1, x1)
gate = tx.Gate(input_layer=x1, gate_input=x2, gate_fn=tf.sigmoid)
gate_module = tx.Module([x1, x2], gate)
x3 = tx.Input([[1, 1, 1, 1]], n_units=4, dtype=tf.float32)
x4 = tx.Input([[1, 1]], n_units=2, dtype=tf.float32)
m2 = gate_module.reuse_with(x3, x4)
result1 = gate_module()
result2 = m2()
result3 = gate_module.compute(x3, x4)
assert tx.tensor_equal(result1, result2 * 2)
assert tx.tensor_equal(result2, result3)
def test_gru_cell():
n_inputs = 4
n_hidden = 2
batch_size = 2
data = tf.ones([batch_size, 4])
inputs = tx.Input(init_value=data, n_units=n_inputs, dtype=tf.float32)
rnn_1 = tx.GRUCell(inputs, n_hidden)
rnn_2 = rnn_1.reuse_with(inputs, rnn_1)
# if we don't wipe the memory it reuses it
rnn_3 = rnn_1.reuse_with(inputs, tx.GRUCell.zero_state(rnn_1.n_units))
res1 = rnn_1()
res2 = rnn_2()
res3 = rnn_3()
assert (batch_size, n_hidden) == np.shape(res1)
assert tx.tensor_equal(res1, res3)
assert not tx.tensor_equal(res1, res2)
def test_lstm_cell():
n_inputs = 4
n_hidden = 2
batch_size = 2
inputs = tx.Input(np.ones([batch_size, n_inputs], np.float32), n_units=n_inputs, constant=True)
rnn1 = tx.LSTMCell(inputs, n_hidden, gate_activation=tf.sigmoid)
previous_state = (None, rnn1.state[-1]())
rnn2 = rnn1.reuse_with(inputs, *previous_state)
# if we don't wipe the memory, memory will be reused
previous_state = (None, tx.LSTMCell.zero_state(rnn1.n_units))
rnn3 = rnn1.reuse_with(inputs, *previous_state)
rnn4 = rnn1.reuse_with(inputs)
res1 = rnn1()
res2 = rnn2()
res3 = rnn3()
res4 = rnn4()
assert (batch_size, n_hidden) == np.shape(res1)
assert tx.tensor_equal(res1, res3)
assert not tx.tensor_equal(res1, res2)
assert tx.tensor_equal(res1, res4)
def test_lstm_cell_regularization():
n_inputs = 8
n_hidden = 2
batch_size = 2
inputs = tx.Input(n_units=n_inputs, constant=False)
rnn1 = tx.LSTMCell(inputs, n_hidden,
u_dropconnect=0.1,
w_dropconnect=0.1,
name="lstm1")
rnn2 = rnn1.reuse_with(inputs,
*rnn1.state,
regularized=True,
name="lstm2"
)
rnn3 = rnn2.reuse_with(inputs,
*rnn1.state,
name="lstm3"
)
data = np.ones([batch_size, n_inputs])
inputs.value = data
assert tx.tensor_equal(rnn2, rnn3)
assert not tx.tensor_equal(rnn1, rnn3)
assert not tx.tensor_equal(rnn1, rnn3)
state2, state3 = rnn2.w_f.weight_mask, rnn3.w_f.weight_mask
assert tx.tensor_equal(state2, state3)
w2, w3 = rnn2.w_f, rnn3.w_f
assert tx.tensor_equal(w2, w3)
w2, w3 = rnn2.w_i, rnn3.w_i
assert tx.tensor_equal(w2, w3)
w2, w3 = rnn2.w_o, rnn3.w_o
assert tx.tensor_equal(w2, w3)
w2, w3 = rnn2.w_c, rnn3.w_c
assert tx.tensor_equal(w2, w3)
def test_lstm_cell_state():
n_inputs = 8
n_hidden = 2
batch = 3
x = tf.ones([batch, n_inputs], dtype=tf.float32)
cell = tx.LSTMCell(x, n_hidden,
u_dropconnect=0.1,
w_dropconnect=0.1,
name="cell")
state = cell.previous_state
assert len(state) == 2
# state = [s() for s in state]
state = tx.Graph.build(inputs=None,
outputs=cell.state)
x = tf.random.uniform([batch, n_inputs])
s = state.compute(x)
state.compute(x, *s)
def test_rnn_layer():
n_features = 5
embed_size = 4
hidden_dim = 3
seq_size = 3
batch_size = 2
inputs = tx.Input(np.random.random([batch_size, seq_size]), n_units=seq_size, dtype=tf.int32)
lookup = tx.Lookup(inputs, seq_size=seq_size, embedding_shape=[n_features, embed_size])
seq = lookup.permute_batch_time()
ones_state = tf.ones([batch_size, hidden_dim])
zero_state = (tf.zeros([batch_size, hidden_dim]))
rnn_proto = tx.RNNCell.config(n_units=hidden_dim)
rnn1 = tx.RNN(seq, cell_config=rnn_proto, previous_state=ones_state, return_state=True)
rnn2 = rnn1.reuse_with(seq)
# problem with RNN layer is that it uses modules that require
# all the params to output the right answer
# we need to supply the default values for the rest or all the inputs
out1, last1 = rnn1()
out2, last2 = rnn2()
assert tx.tensor_equal(out1, out2)
assert tx.tensor_equal(last1, last2)
rnn3 = rnn1.reuse_with(seq, zero_state)
rnn4 = rnn3.reuse_with(seq)
rnn5 = rnn4.reuse_with(seq, ones_state)
assert tx.tensor_equal(rnn2.previous_state, rnn1.previous_state)
assert tx.tensor_equal(rnn3.previous_state, rnn4.previous_state)
out3, last3 = rnn3()
out4, last4 = rnn4()
assert tx.tensor_equal(out3, out4)
assert tx.tensor_equal(last3, last4)
cell_state1 = rnn1.cell.previous_state[0]()
cell_state2 = rnn2.cell.previous_state[0]()
cell_state3 = rnn3.cell.previous_state[0]()
cell_state4 = rnn4.cell.previous_state[0]()
assert len(rnn1.cell.previous_state) == 1
assert tx.tensor_equal(cell_state1, cell_state2)
assert tx.tensor_equal(cell_state3, cell_state4)
assert not tx.tensor_equal(out1, out3)
out5, last5 = rnn5()
assert tx.tensor_equal(out1, out5)
assert tx.tensor_equal(last1, last5)
def test_biRNN():
# bidirectional RNN
n_features = 5
embed_size = 4
hidden_dim = 3
seq_size = 6
batch_size = 2
inputs = tx.Input(np.random.random([batch_size, seq_size]), n_units=seq_size, dtype=tf.int32)
lookup = tx.Lookup(inputs, seq_size=seq_size, embedding_shape=[n_features, embed_size])
seq = lookup.permute_batch_time()
rnn_proto = tx.RNNCell.config(n_units=hidden_dim)
rnn0 = tx.RNN(seq, cell_config=rnn_proto, stateful=False, return_state=True)
# because a stateful rnn0 has a variable layer as input as well
rnn_m0 = tx.Module(inputs=rnn0.inputs, output=rnn0)
rnn1 = rnn0.reuse_with(seq, reverse=True, stateful=False, return_state=True)
# this solves rnn output multiple tensors
r01 = rnn_m0.compute(seq(), rnn0.previous_state[0]())
rnn0.reset()
r02 = rnn0()
assert tx.tensor_equal(r01[0], r02[0])
rnn0_0 = rnn0[0]
rnn1_0 = rnn1[0]
rnn0 = tx.Wrap(rnn0, wrap_fn=lambda y: y[0], n_units=rnn0.n_units)
rnn1 = tx.Wrap(rnn1, wrap_fn=lambda y: y[0], n_units=rnn1.n_units)
rnn0_tensor = rnn0()
rnn1_tensor = rnn1()
rnn0_0_tensor = rnn0_0()
print(rnn0_tensor.shape)
print(rnn0_0_tensor.shape)
# assert tx.same_shape(rnn0(), rnn1())
# assert tx.same_shape(rnn1(), rnn1_0())
def test_batch_norm():
v = tf.random.uniform([3, 4])
x = tx.Input(v, dtype=tf.float32)
bn = tx.BatchNorm(x, offset=True, scale=True)
moving_mean = bn.moving_mean
moving_variance = bn.moving_variance
before = bn.moving_mean.value()
bn()
after = bn.moving_mean.value()
assert not tx.tensor_equal(before, after)
x.value = tf.random.uniform([3, 4])
bn = bn.reuse_with(x, training=False)
before = bn.moving_mean.value()
bn()
after = bn.moving_mean.value()
assert tx.tensor_equal(before, after)
assert moving_mean is bn.moving_mean
assert moving_variance is bn.moving_variance
bn = bn.reuse_with(x, training=True)
x.value = tf.random.uniform([3, 4])
before = bn.moving_mean.value()
bn()
after = bn.moving_mean.value()
assert not tx.tensor_equal(before, after)
def test_stateful_rnn_layer():
n_features = 5
embed_size = 4
hidden_dim = 3
seq_size = 3
batch_size = 2
inputs = tx.Input(np.random.random([batch_size, seq_size]), n_units=seq_size, dtype=tf.int32)
lookup = tx.Lookup(inputs, seq_size=seq_size, embedding_shape=[n_features, embed_size])
seq = lookup.permute_batch_time()
rnn_proto = tx.RNNCell.config(n_units=hidden_dim)
rnn1 = tx.RNN(seq, cell_config=rnn_proto, stateful=True, return_state=True)
lstm1 = tx.RNN(seq, cell_config=tx.LSTMCell.config(n_units=hidden_dim), stateful=True, return_state=True)
zero_state0 = [layer() for layer in rnn1.previous_state]
assert len(zero_state0) == 1
expected_state = tf.zeros([1, hidden_dim], dtype=tf.float32)
assert tx.tensor_equal(zero_state0[0], expected_state)
# import logging
# logging.getLogger("tensorx").setLevel(logging.DEBUG)
out1, state1 = rnn1()
tx.Graph.build(inputs=None, outputs=lstm1)
# out2, state2 = lstm1()
lstm1()
# state after single run
# zero_state1 = [layer() for layer in ]
zero_state1 = rnn1.previous_state[0]()
assert tx.tensor_equal(zero_state1, state1)
rnn1.reset()
reset_state = rnn1.previous_state[0]()
assert tx.tensor_equal(reset_state, zero_state0[0])
def test_lookup_config():
inputs = tx.Input(np.array([[2, 0], [1, 2]]), 2, dtype=tf.int64)
lookup = tx.Lookup(inputs, None,
embedding_shape=[2, 10],
batch_size=None,
batch_padding=True)
assert lookup.config['embedding_shape'] == [2, 10]
assert lookup.config['batch_size'] is None
assert lookup.config['batch_padding'] is True
assert lookup.config['seq_size'] is None
def test_lookup_sequence_mismatch():
inputs = tx.Input(np.array([[2, 0], [1, 2]]), 2, dtype=tf.int64)
lookup = tx.Lookup(inputs, None,
embedding_shape=[2, 10],
batch_size=None,
batch_padding=True)
assert lookup.shape.is_compatible_with(lookup().shape)
lookup = tx.Lookup(inputs, 1,
embedding_shape=[2, 10],
batch_size=None,
batch_padding=True)
# not validating seq_len differing from input seq_len
assert lookup.batch_size is None
assert lookup.shape.is_compatible_with(lookup().shape)
def test_lookup_sequence_dense():
input_dim = 4
embed_dim = 3
seq_size = 2
batch_size = 3
inputs = tx.Input(np.array([[2, 0], [1, 2]]), 2, dtype=tf.int64)
tensor_input = tx.Input(tf.constant([2]), 1, dtype=tf.int64)
lookup = tx.Lookup(inputs, seq_size,
embedding_shape=[input_dim, embed_dim],
batch_size=batch_size,
batch_padding=True)
lookup_from_tensor = lookup.reuse_with(tensor_input)
v1 = lookup()
v2 = lookup_from_tensor()
assert np.shape(v1) == (batch_size, seq_size, embed_dim)
assert np.shape(v2) == (batch_size, seq_size, embed_dim)
def test_as_concat_wrap():
n = 10
h = 4
inputs = tx.Input(dtype=tf.int32, constant=False)
lookup = tx.Lookup(inputs, seq_size=None, embedding_shape=[n, h])
assert tx.shape_equal(lookup.shape, (None, None, h))
concat = lookup.as_concat()
assert tx.shape_equal(concat.shape, (None, None))
lookup = tx.Lookup(inputs, seq_size=2, embedding_shape=[n, h])
concat = lookup.as_concat()
assert tx.shape_equal(concat.shape, (None, 2 * 4))
seq1 = [[1, 2], [3, 4]]
inputs.value = seq1
concat_tensor = concat()
assert concat_tensor.shape[-1] == concat.shape[-1]
def test_lookup_dynamic_sequence():
seq1 = [[1, 2], [3, 4]]
seq2 = [[1, 2, 3], [4, 5, 6]]
n = 10
h = 4
inputs = tx.Input(dtype=tf.int32, constant=False)
lookup = tx.Lookup(inputs, seq_size=None, embedding_shape=[n, h])
assert tx.shape_equal(lookup.shape, (None, None, h))
concat = lookup.as_concat()
inputs.value = seq1
inputs.value = seq1
inputs()
inputs.value = seq2
inputs()
inputs.value = seq1
l1 = lookup()
inputs.value = seq2
l2 = lookup()
inputs.value = seq1
c1 = concat()
inputs.value = seq2
c2 = concat()
assert np.shape(l1)[-1] == h
assert np.shape(l2)[-1] == h
assert np.shape(c1)[-1] == h * 2
assert | np.shape(c2) | numpy.shape |
import torch.utils.data as data
import sys
sys.path.append('/home/benkesheng/BMI_DETECT/')
from sklearn.metrics import mean_absolute_error
from sklearn.svm import SVR
from Detected import Image_Processor
import torch
import torch.nn as nn
import torch.utils.data as data
from torchvision import models, transforms
import numpy as np
import os
import pandas as pd
import cv2
import re
import csv
from PIL import Image
from Data import Img_info
import random
def setup_seed(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
torch.backends.cudnn.deterministic = True
setup_seed(20)
END_EPOCH = 0
mask_model = "/home/benkesheng/BMI_DETECT/pose2seg_release.pkl"
keypoints_model = "COCO-Keypoints/keypoint_rcnn_R_101_FPN_3x.yaml"
# P = Image_Processor(mask_model,keypoints_model)
IMG_MEAN = [0.485, 0.456, 0.406]
IMG_STD = [0.229, 0.224, 0.225]
DEVICE = torch.device("cuda:3")
IMG_SIZE = 224
BATCH_SIZE = 64
def _get_image_size(img):
if transforms.functional._is_pil_image(img):
return img.size
elif isinstance(img, torch.Tensor) and img.dim() > 2:
return img.shape[-2:][::-1]
else:
raise TypeError("Unexpected type {}".format(type(img)))
class Resize(transforms.Resize):
def __call__(self, img):
h, w = _get_image_size(img)
scale = max(w, h) / float(self.size)
new_w, new_h = int(w / scale), int(h / scale)
return transforms.functional.resize(img, (new_w, new_h), self.interpolation)
class Dataset(data.Dataset):
def __init__(self, file, transfrom):
self.Pic_Names = os.listdir(file)
self.file = file
self.transfrom = transfrom
def __len__(self):
return len(self.Pic_Names)
def __getitem__(self, idx):
img_name = self.Pic_Names[idx]
Pic = Image.open(os.path.join(self.file, self.Pic_Names[idx]))
Pic = self.transfrom(Pic)
try:
ret = re.match(r"\d+?_([FMfm])_(\d+?)_(\d+?)_(\d+).+", img_name)
BMI = (int(ret.group(4)) / 100000) / (int(ret.group(3)) / 100000) ** 2
Pic_name = os.path.join(self.file, self.Pic_Names[idx])
return (Pic, Pic_name), BMI
except:
return (Pic, ''), 10000
transform = transforms.Compose([
Resize(IMG_SIZE),
transforms.Pad(IMG_SIZE),
transforms.CenterCrop(IMG_SIZE),
transforms.ToTensor(),
transforms.Normalize(IMG_MEAN, IMG_STD)
])
dataset = Dataset('/home/benkesheng/BMI_DETECT/datasets/Image_train', transform)
# val_dataset = Dataset('/home/benkesheng/BMI_DETECT/datasets/Image_val', transform)
test_dataset = Dataset('/home/benkesheng/BMI_DETECT/datasets/Image_test', transform)
train_size = int(0.8 * len(dataset))
val_size = len(dataset) - train_size
train_dataset, val_dataset = torch.utils.data.random_split(dataset, [train_size, val_size])
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=1, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1, shuffle=True)
# Vgg16
# Pred_Net = torchvision.models.vgg16(pretrained=True)
# for param in Pred_Net.parameters():
# param.requires_grad = True
#
# Pred_Net.classifier = nn.Sequential(
# nn.Linear(25088, 1024),
# nn.ReLU(True),
# nn.Linear(1024, 512),
# nn.ReLU(True),
# nn.Linear(512, 256),
# nn.ReLU(True),
# nn.Linear(256, 20),
# nn.ReLU(True),
# nn.Linear(20, 1)
# )
# Resnet101
Pred_Net = models.resnet101(pretrained=True,num_classes= 1)
print(Pred_Net)
for param in Pred_Net.parameters():
param.requires_grad = True
# Pred_Net.fc = nn.Sequential(
# nn.Linear(2048, 1024),
# nn.ReLU(True),
# nn.Linear(1024, 512),
# nn.ReLU(True),
# nn.Linear(512, 256),
# nn.ReLU(True),
# nn.Linear(256, 20),
# nn.ReLU(True),
# nn.Linear(20, 1)
# )
Pred_Net = Pred_Net.to(DEVICE)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam([
{'params': Pred_Net.parameters()}
], lr=0.0001)
def train(model, device, train_loader, epoch):
model.train()
runing_loss = 0.0
for idx, ((x, n), y) in enumerate(train_loader, 0):
x, y = x.to(device), y.to(device)
optimizer.zero_grad()
y_pred = model(x)
# print(y_pred.shape)
y = torch.unsqueeze(y, 1)
loss = criterion(y_pred.double(), y.double())
loss.backward()
optimizer.step()
runing_loss += loss.item()
print('loss:', loss.item())
print('Train Epoch:{}\t RealLoss:{:.6f}'.format(epoch, runing_loss / len(train_loader)))
def mean_absolute_percentage_error(y_true, y_pred):
y_true, y_pred = np.array(y_true), np.array(y_pred)
return np.mean( | np.abs((y_true - y_pred) / y_true) | numpy.abs |
# python/example1.py -- Python version of an example application that shows
# how to use the various widget classes. For a C++ implementation, see
# '../src/example1.cpp'.
#
# NanoGUI was developed by <NAME> <<EMAIL>>.
# The widget drawing code is based on the NanoVG demo application
# by <NAME>.
#
# All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE.txt file.
import nanogui
import math
import time
import gc
import numpy as np
from nanogui import Color, ColorPicker, Screen, Window, GroupLayout, \
BoxLayout, ToolButton, Label, Button, Widget, \
Popup, PopupButton, CheckBox, MessageDialog, \
VScrollPanel, ImagePanel, ImageView, ComboBox, \
ProgressBar, Slider, TextBox, ColorWheel, Graph, \
GridLayout, Alignment, Orientation, TabWidget, \
IntBox, RenderPass, Shader, Texture, Matrix4f
from nanogui import glfw, icons
# A simple counter, used for dynamic tab creation with TabWidget callback
counter = 1
class TestApp(Screen):
def __init__(self):
super(TestApp, self).__init__((1024, 768), "NanoGUI Test")
self.shader = None
window = Window(self, "Button demo")
window.set_position((15, 15))
window.set_layout(GroupLayout())
Label(window, "Push buttons", "sans-bold")
b = Button(window, "Plain button")
def cb():
print("pushed!")
b.set_callback(cb)
b = Button(window, "Styled", icons.FA_ROCKET)
b.set_background_color(Color(0, 0, 1.0, 0.1))
b.set_callback(cb)
Label(window, "Toggle buttons", "sans-bold")
b = Button(window, "Toggle me")
b.set_flags(Button.Flags.ToggleButton)
def change_cb(state):
print("Toggle button state: %s" % str(state))
b.set_change_callback(change_cb)
Label(window, "Radio buttons", "sans-bold")
b = Button(window, "Radio button 1")
b.set_flags(Button.Flags.RadioButton)
b = Button(window, "Radio button 2")
b.set_flags(Button.Flags.RadioButton)
Label(window, "A tool palette", "sans-bold")
tools = Widget(window)
tools.set_layout(BoxLayout(Orientation.Horizontal,
Alignment.Middle, 0, 6))
ToolButton(tools, icons.FA_CLOUD)
ToolButton(tools, icons.FA_FAST_FORWARD)
ToolButton(tools, icons.FA_COMPASS)
ToolButton(tools, icons.FA_UTENSILS)
Label(window, "Popup buttons", "sans-bold")
popup_btn = PopupButton(window, "Popup", icons.FA_FLASK)
popup = popup_btn.popup()
popup.set_layout(GroupLayout())
Label(popup, "Arbitrary widgets can be placed here")
CheckBox(popup, "A check box")
# popup right
popup_btn = PopupButton(popup, "Recursive popup", icons.FA_CHART_PIE)
popup_right = popup_btn.popup()
popup_right.set_layout(GroupLayout())
CheckBox(popup_right, "Another check box")
# popup left
popup_btn = PopupButton(popup, "Recursive popup", icons.FA_DNA)
popup_btn.set_side(Popup.Side.Left)
popup_left = popup_btn.popup()
popup_left.set_layout(GroupLayout())
CheckBox(popup_left, "Another check box")
window = Window(self, "Basic widgets")
window.set_position((200, 15))
window.set_layout(GroupLayout())
Label(window, "Message dialog", "sans-bold")
tools = Widget(window)
tools.set_layout(BoxLayout(Orientation.Horizontal,
Alignment.Middle, 0, 6))
def cb2(result):
print("Dialog result: %i" % result)
b = Button(tools, "Info")
def cb():
dlg = MessageDialog(self, MessageDialog.Type.Information, "Title",
"This is an information message")
dlg.set_callback(cb2)
b.set_callback(cb)
b = Button(tools, "Warn")
def cb():
dlg = MessageDialog(self, MessageDialog.Type.Warning, "Title",
"This is a warning message")
dlg.set_callback(cb2)
b.set_callback(cb)
b = Button(tools, "Ask")
def cb():
dlg = MessageDialog(self, MessageDialog.Type.Warning, "Title",
"This is a question message", "Yes", "No",
True)
dlg.set_callback(cb2)
b.set_callback(cb)
import os
import sys
os.chdir(sys.path[0])
try:
icons_data = nanogui.load_image_directory(self.nvg_context(), "icons")
except:
try:
icons_data = nanogui.load_image_directory(self.nvg_context(), "../icons")
except:
icons_data = nanogui.load_image_directory(self.nvg_context(), "../resources/icons")
Label(window, "Image panel & scroll panel", "sans-bold")
image_panel_btn = PopupButton(window, "Image Panel")
image_panel_btn.set_icon(icons.FA_IMAGES)
popup = image_panel_btn.popup()
vscroll = VScrollPanel(popup)
img_panel = ImagePanel(vscroll)
img_panel.set_images(icons_data)
popup.set_fixed_size((245, 150))
img_window = Window(self, "Selected image")
img_window.set_position((710, 15))
img_window.set_layout(GroupLayout())
img_view = ImageView(img_window)
img_view.set_image(Texture(icons_data[0][1] + ".png",
Texture.InterpolationMode.Trilinear,
Texture.InterpolationMode.Nearest))
img_view.center()
def cb(i):
print("Selected item %i" % i)
img_view.set_image(Texture(icons_data[i][1] + ".png",
Texture.InterpolationMode.Trilinear,
Texture.InterpolationMode.Nearest))
img_panel.set_callback(cb)
Label(window, "File dialog", "sans-bold")
tools = Widget(window)
tools.set_layout(BoxLayout(Orientation.Horizontal,
Alignment.Middle, 0, 6))
b = Button(tools, "Open")
valid = [("png", "Portable Network Graphics"), ("txt", "Text file")]
def cb():
result = nanogui.file_dialog(valid, False)
print("File dialog result = %s" % result)
b.set_callback(cb)
b = Button(tools, "Save")
def cb():
result = nanogui.file_dialog(valid, True)
print("File dialog result = %s" % result)
b.set_callback(cb)
Label(window, "Combo box", "sans-bold")
ComboBox(window, ["Combo box item 1", "Combo box item 2",
"Combo box item 3"])
Label(window, "Check box", "sans-bold")
def cb(state):
print("Check box 1 state: %s" % state)
chb = CheckBox(window, "Flag 1", cb)
chb.set_checked(True)
def cb(state):
print("Check box 2 state: %s" % state)
CheckBox(window, "Flag 2", cb)
Label(window, "Progress bar", "sans-bold")
self.progress = ProgressBar(window)
Label(window, "Slider and text box", "sans-bold")
panel = Widget(window)
panel.set_layout(BoxLayout(Orientation.Horizontal,
Alignment.Middle, 0, 20))
slider = Slider(panel)
slider.set_value(0.5)
slider.set_fixed_width(80)
text_box = TextBox(panel)
text_box.set_fixed_size((60, 25))
text_box.set_value("50")
text_box.set_units("%")
text_box.set_font_size(20)
text_box.set_alignment(TextBox.Alignment.Right)
def cb(value):
text_box.set_value("%i" % int(value * 100))
slider.set_callback(cb)
def cb(value):
print("Final slider value: %i" % int(value * 100))
slider.set_final_callback(cb)
window = Window(self, "Misc. widgets")
window.set_position((425, 15))
window.set_layout(GroupLayout())
tab_widget = TabWidget(window)
layer = Widget(tab_widget)
layer.set_layout(GroupLayout())
tab_widget.append_tab("Color Wheel", layer)
Label(layer, "Color wheel widget", "sans-bold")
ColorWheel(layer)
layer = Widget(tab_widget)
layer.set_layout(GroupLayout())
tab_widget.append_tab("Function Graph", layer)
Label(layer, "Function graph widget", "sans-bold")
graph = Graph(layer, "Some function")
graph.set_header("E = 2.35e-3")
graph.set_footer("Iteration 89")
values = [0.5 * (0.5 * math.sin(i / 10.0) +
0.5 * math.cos(i / 23.0) + 1)
for i in range(100)]
graph.set_values(values)
# Dummy tab used to represent the last tab button.
plus_id = tab_widget.append_tab("+", Widget(tab_widget))
def tab_cb(index):
if index == plus_id:
global counter
# When the "+" tab has been clicked, simply add a new tab.
tab_name = "Dynamic {0}".format(counter)
layer_dyn = Widget(tab_widget)
layer_dyn.set_layout(GroupLayout())
new_id = tab_widget.insert_tab(tab_widget.tab_count() - 1,
tab_name, layer_dyn)
Label(layer_dyn, "Function graph widget", "sans-bold")
graph_dyn = Graph(layer_dyn, "Dynamic function")
graph_dyn.set_header("E = 2.35e-3")
graph_dyn.set_footer("Iteration {0}".format(index*counter))
values_dyn = [0.5 * abs((0.5 * math.sin(i / 10.0 + counter)) +
(0.5 * math.cos(i / 23.0 + 1 + counter)))
for i in range(100)]
graph_dyn.set_values(values_dyn)
counter += 1
# We must invoke the layout manager after adding tabs dynamically
self.perform_layout()
tab_widget.set_selected_id(new_id)
tab_widget.set_callback(tab_cb)
window = Window(self, "Grid of small widgets")
window.set_position((425, 300))
layout = GridLayout(Orientation.Horizontal, 2,
Alignment.Middle, 15, 5)
layout.set_col_alignment(
[Alignment.Maximum, Alignment.Fill])
layout.set_spacing(0, 10)
window.set_layout(layout)
Label(window, "Floating point :", "sans-bold")
float_box = TextBox(window)
float_box.set_editable(True)
float_box.set_fixed_size((100, 20))
float_box.set_value("50")
float_box.set_units("GiB")
float_box.set_default_value("0.0")
float_box.set_font_size(16)
float_box.set_format("[-]?[0-9]*\\.?[0-9]+")
Label(window, "Positive integer :", "sans-bold")
int_box = IntBox(window)
int_box.set_editable(True)
int_box.set_fixed_size((100, 20))
int_box.set_value(50)
int_box.set_units("Mhz")
int_box.set_default_value("0")
int_box.set_font_size(16)
int_box.set_format("[1-9][0-9]*")
int_box.set_spinnable(True)
int_box.set_min_value(1)
int_box.set_value_increment(2)
Label(window, "Checkbox :", "sans-bold")
cb = CheckBox(window, "Check me")
cb.set_font_size(16)
cb.set_checked(True)
Label(window, "Combo box :", "sans-bold")
cobo = ComboBox(window, ["Item 1", "Item 2", "Item 3"])
cobo.set_font_size(16)
cobo.set_fixed_size((100, 20))
Label(window, "Color picker :", "sans-bold")
cp = ColorPicker(window, Color(255, 120, 0, 255))
cp.set_fixed_size((100, 20))
def cp_final_cb(color):
print(
"ColorPicker Final Callback: [{0}, {1}, {2}, {3}]".format(color.r,
color.g,
color.b,
color.w)
)
cp.set_final_callback(cp_final_cb)
# setup a fast callback for the color picker widget on a new window
# for demonstrative purposes
window = Window(self, "Color Picker Fast Callback")
window.set_position((425, 300))
layout = GridLayout(Orientation.Horizontal, 2,
Alignment.Middle, 15, 5)
layout.set_col_alignment(
[Alignment.Maximum, Alignment.Fill])
layout.set_spacing(0, 10)
window.set_layout(layout)
window.set_position((425, 500))
Label(window, "Combined: ")
b = Button(window, "ColorWheel", icons.FA_INFINITY)
Label(window, "Red: ")
red_int_box = IntBox(window)
red_int_box.set_editable(False)
Label(window, "Green: ")
green_int_box = IntBox(window)
green_int_box.set_editable(False)
Label(window, "Blue: ")
blue_int_box = IntBox(window)
blue_int_box.set_editable(False)
Label(window, "Alpha: ")
alpha_int_box = IntBox(window)
def cp_fast_cb(color):
b.set_background_color(color)
b.set_text_color(color.contrasting_color())
red = int(color.r * 255.0)
red_int_box.set_value(red)
green = int(color.g * 255.0)
green_int_box.set_value(green)
blue = int(color.b * 255.0)
blue_int_box.set_value(blue)
alpha = int(color.w * 255.0)
alpha_int_box.set_value(alpha)
cp.set_callback(cp_fast_cb)
self.perform_layout()
self.render_pass = RenderPass([self])
self.render_pass.set_clear_color(0, Color(0.3, 0.3, 0.32, 1.0))
if nanogui.api == 'opengl':
vertex_shader = """
#version 330
uniform mat4 mvp;
in vec3 position;
void main() {
gl_Position = mvp * vec4(position, 1.0);
}"""
fragment_shader = """
#version 330
out vec4 color;
uniform float intensity;
void main() {
color = vec4(vec3(intensity), 1.0);
}"""
elif nanogui.api == 'gles2' or nanogui.api == 'gles3':
vertex_shader = """
precision highp float;
uniform mat4 mvp;
attribute vec3 position;
void main() {
gl_Position = mvp * vec4(position, 1.0);
}"""
fragment_shader = """
precision highp float;
uniform float intensity;
void main() {
gl_FragColor = vec4(vec3(intensity), 1.0);
}"""
elif nanogui.api == 'metal':
vertex_shader = """
using namespace metal;
struct VertexOut {
float4 position [[position]];
};
vertex VertexOut vertex_main(const device packed_float3 *position,
constant float4x4 &mvp,
uint id [[vertex_id]]) {
VertexOut vert;
vert.position = mvp * float4(position[id], 1.f);
return vert;
}"""
fragment_shader = """
using namespace metal;
fragment float4 fragment_main(const constant float &intensity) {
return float4(intensity);
}"""
self.shader = Shader(
self.render_pass,
# An identifying name
"A simple shader",
vertex_shader,
fragment_shader
)
self.shader.set_buffer("indices", np.array([0, 1, 2, 2, 3, 0], dtype=np.uint32))
self.shader.set_buffer("position", np.array(
[[-1, -1, 0],
[1, -1, 0],
[1, 1, 0],
[-1, 1, 0]],
dtype=np.float32
))
self.shader.set_buffer("intensity", np.array(0.5, dtype=np.float32))
def draw(self, ctx):
self.progress.set_value(math.fmod(time.time() / 10, 1))
super(TestApp, self).draw(ctx)
def draw_contents(self):
if self.shader is None:
return
self.render_pass.resize(self.framebuffer_size())
s = self.size()
with self.render_pass:
mvp = Matrix4f.scale([s[1] / float(s[0]) * 0.25, 0.25, 0.25]) @ \
Matrix4f.rotate([0, 0, 1], glfw.getTime())
self.shader.set_buffer("mvp", | np.float32(mvp) | numpy.float32 |
# Copyright 2022 The jax3d Authors.
#
# 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.
"""Utility functions."""
from typing import Callable, List, Optional
import chex
import flax
import jax
import jax.numpy as jnp
import jax3d.projects.nesf as j3d
from jax3d.projects.nesf.nerfstatic.metrics import metrics
from jax3d.projects.nesf.nerfstatic.nerf import colormap
from jax3d.projects.nesf.nerfstatic.utils import types
from jax3d.projects.nesf.utils.typing import PathLike
from jax3d.projects.nesf.utils.typing import Tree, f32, i32 # pylint: disable=g-multiple-import
import numpy as np
from PIL import Image
# This cannot be a chex.dataclass, b/c this is not supported by msgpack.
@flax.struct.dataclass
class TrainState:
optimizer: flax.optim.Optimizer
@chex.dataclass
class ReconstructionStats:
"""Reconstruction model statistics for the losses and metrics."""
coarse_model: types.ReconstructionModelStats
fine_model: types.ReconstructionModelStats
regularization: types.LossTerm
ray_regularization: types.LossTerm
@property
def total(self) -> float:
return (self.coarse_model.total + self.fine_model.total +
self.regularization.value + self.ray_regularization.value)
@chex.dataclass
class SemanticStats:
"""Semantic Model statistics for the losses and metrics."""
semantic_model: types.SemanticModelStats
regularization: types.LossTerm
@property
def total(self) -> float:
semantic_model_total = jnp.array(self.semantic_model.total)
assert not semantic_model_total.shape, semantic_model_total.shape
regularization_value = self.regularization.value
assert not regularization_value.shape, regularization_value.shape
return semantic_model_total + regularization_value
def render_image(render_fn: Callable[[int, types.Rays], types.RenderResult],
rays: types.Rays,
normalize_disp,
chunk) -> types.RenderedRays:
"""Render all the pixels of an image (in test mode).
This function ensures that 'rays' is evenly split across all hosts if using
a multi-host evaluation setup. While each host receives
the same super batch, only a subset of rays are evaluated by devices attached
to this host. This only works if 'rays' is identical on each host.
This function ensures a maximum of 'chunk' rays are processed at one time.
This upper bounds the memory usage of the underlying devices.
WARNING: !! HERE THERE BE DRAGONS !!
The following chunk of code efficiently uses a TPU Pod slice for inference.
Let 'num_local_devices' be the number of TPU cores attached to this host and
'num_total_devices' be the total number of TPU cores across all hosts. This
computation depends on the following assumptions,
1) Each TPU host has the same value for 'rays'.
2) render_fn: $INPUT -> $OUTPUT is such that $INPUT is of shape
[num_local_devices, batch_size_per_device, ...] and $OUTPUT is of
shape [num_local_devices, num_total_devices, batch_size_per_device].
3) Each $INPUT[i, j] is operated upon independently of $INPUT[i', j']
for all choices of (i, j), (i', j'). Communication within the same
batch, such as via BatchNorm, is not allowed.
4) $OUTPUT[0] == ... == $OUTPUT[num_local_devices-1].
5) $OUTPUT fits in host RAM.
If any of the above are violated, this code will do The Wrong Thing (TM).
TODO(duckworthd): Consider migrating pmap(all_gather(..)) inside of this
function. Doing so will ensure that the assumptions above are hidden from
the caller.
Args:
render_fn: function, jit-ed render function.
rays: a `Rays` namedtuple, the rays to be rendered. The shape of this objext
*must* be [H W C], i.e. it contains rays for a single image.
normalize_disp: bool, if true then normalize `disp` to [0, 1].
chunk: int, the size of chunks to render sequentially.
Returns:
A types.RenderedRays object.
"""
if len(rays.batch_shape) != 2:
raise ValueError("rays must have exactly rank 3 (i.e. 2 batch dimensions). "
"Expected batch shape: [H W] "
f"Actual batch shape: {rays.batch_shape}")
# Transform 'rays' into a bag-of-rays representation.
height, width = rays.batch_shape
num_rays = height * width
rays = jax.tree_map(lambda r: r.reshape((num_rays, -1)), rays)
process_index = jax.process_index()
results = []
for i in range(0, num_rays, chunk):
# pylint: disable=cell-var-from-loop
# Split 'rays' into smaller, bite-sized bits that fit in device memory.
# Result is of shape,
# [chunk, ...]
# Requires Assumption (3): no cross-batch communication.
chunk_rays = jax.tree_map(lambda r: r[i:i + chunk], rays)
chunk_size = chunk_rays.origin.shape[0]
# Pad pseudo-examples at the end of this 'chunk_rays' to ensure that each
# device is operating on an ndarray of the same shape.
#
# Requires Assumption (3): no cross-batch communication.
rays_remaining = chunk_size % jax.device_count()
if rays_remaining != 0:
padding = jax.device_count() - rays_remaining
chunk_rays = jax.tree_map(
lambda r: jnp.pad(r, ((0, padding), (0, 0)), mode="edge"), chunk_rays)
else:
padding = 0
# After padding the number of chunk_rays is always divisible by
# process_count.
rays_per_process = chunk_rays.origin.shape[0] // jax.process_count()
# Identify the subset of 'chunk_rays' that this host is responsible for.
# If each host is processing the same value for 'chunk_rays', then we can
# reconstruct the full 'render_fn(chunk_rays)' at the end.
start = process_index * rays_per_process
stop = start + rays_per_process
# Reshape chunk_rays to shape,
# [num_local_devices, batch_size_per_device, ...]
# Requires Assumption (1): Each host has same input 'rays'.
chunk_rays = jax.tree_map(lambda r: shard(r[start:stop]), chunk_rays)
# Apply inference function. Result is of shape,
# [num_local_devices, num_total_devices, batch_size_per_device, ...]
# Requires Assumption (1): Each host has same input 'rays'.
# Requires Assumption (2): Input/Output shapes.
fine = render_fn(chunk_rays)[0].fine
sigma_grid = fine.sigma_grid
# Remove sigma_grid from fine to avoid error when reshapping.
fine.sigma_grid = None
# Undo sharding operation. We select $OUTPUT[0] for each result as
# $OUTPUT[0] == ... == $OUTPUT[num_local_devices-1].
# After unshard(), result is of shape,
# [chunk, ...]
# Requires Assumption (4): Each device returns the same value.
# Requires Assumption (5): Output fits in RAM.
fine = jax.tree_map(lambda x: unshard(x[0], padding=padding), fine)
results.append(fine)
# pylint: enable=cell-var-from-loop
# Merge each list of ndarrays into one ndarray of shape [num_rays, ...].
# Signature: `tree_multimap(fn, *arrs: RenderedRays) -> RenderedRays`
# fn has signature `fn(*arrs: Array) -> Array`
results = jax.tree_multimap(
lambda *arrs: jnp.concatenate(arrs, axis=0),
*results,
)
# Reshape each ndarray to [height, width, num_channels].
results = jax.tree_map(lambda x: x.reshape(height, width, -1), results)
# Normalize disp for visualization for scenes that aren't scaled in [0, 1].
if normalize_disp:
disp = results.disparity
# Zero disparity is ignored for normalization since those are only produced
# by masked padding pixels.
min_disp = jnp.min(disp[jnp.nonzero(disp)])
max_disp = jnp.max(disp)
disp = (disp - min_disp) / (max_disp - min_disp)
results = results.replace(disparity=disp)
# Sigma_grid is the same for every ray in this batch as the rays belong to
# a single image from a single scene.
if sigma_grid is not None:
# the first 3 axes are batch, height, width which are repeated across all
# sigma_grids.
results.sigma_grid = sigma_grid[0, 0, 0]
return results
# TODO(svora): Merge predict_2d_semantic with render_image when finalized.
def predict_2d_semantic(
render_pfn: Callable[..., types.RenderResult],
rng: j3d.RandomState,
rays: types.Rays,
nerf_variables: Tree[jnp.ndarray],
nerf_sigma_grid: f32["1 x y z c"],
chunk: int) -> types.RenderedRays:
"""Render all the pixels of an image (in test mode) for semantic decoder.
Args:
render_pfn: Rendering function. Arguments must be the following,
rng - jax.random.PRNGKey. Random key.
rays - types.Rays. Rays to predict semantics for.
nerf_variables - Tree[jnp.ndarray]. NeRF variables.
nerf_sigma_grid - f32["1 x y z c"]. NeRF density grid.
rng: Random number generator.
rays: a `Rays` object. The rays to be rendered. The shape of this objext
*must* be [H W C], i.e. it contains rays for a single image.
nerf_variables: NeRF model variables.
nerf_sigma_grid: NeRF sigma grid.
chunk: Maximum number of rays to process at a time.
Returns:
A types.RenderedRays object.
"""
if len(rays.batch_shape) != 2:
raise ValueError("rays must have exactly rank 3 (i.e. 2 batch dimensions). "
"Expected batch shape: [H W] "
f"Actual batch shape: {rays.batch_shape}")
# Transform 'rays' into a bag-of-rays representation.
height, width = rays.batch_shape
num_rays = height * width
rays = jax.tree_map(lambda r: r.reshape((num_rays, -1)), rays)
process_index = jax.process_index()
results = []
for i in range(0, num_rays, chunk):
# pylint: disable=cell-var-from-loop
# Split 'rays' into smaller, bite-sized bits that fit in device memory.
# Result is of shape,
# [chunk, ...]
# Requires Assumption (3): no cross-batch communication.
chunk_rays = jax.tree_map(lambda r: r[i:i + chunk], rays)
chunk_size = chunk_rays.origin.shape[0]
# Pad pseudo-examples at the end of this 'chunk_rays' to ensure that each
# device is operating on an ndarray of the same shape.
#
# Requires Assumption (3): no cross-batch communication.
rays_remaining = chunk_size % jax.device_count()
if rays_remaining != 0:
padding = jax.device_count() - rays_remaining
chunk_rays = jax.tree_map(
lambda r: jnp.pad(r, ((0, padding), (0, 0)), mode="edge"), chunk_rays)
else:
padding = 0
# After padding the number of chunk_rays is always divisible by
# process_count.
rays_per_process = chunk_rays.origin.shape[0] // jax.process_count()
# Identify the subset of 'chunk_rays' that this host is responsible for.
# If each host is processing the same value for 'chunk_rays', then we can
# reconstruct the full 'render_pfn(chunk_rays)' at the end.
start = process_index * rays_per_process
stop = start + rays_per_process
# Reshape chunk_rays to shape,
# [num_local_devices, batch_size_per_device, ...]
# Requires Assumption (1): Each host has same input 'rays'.
chunk_rays = jax.tree_map(lambda r: shard(r[start:stop]), chunk_rays)
# Apply inference function. Result is of shape,
# [num_local_devices, num_total_devices, batch_size_per_device, ...]
# Requires Assumption (1): Each host has same input 'rays'.
# Requires Assumption (2): Input/Output shapes.
fine = render_pfn(rng.next(), chunk_rays, nerf_variables, nerf_sigma_grid)
# Undo sharding operation. We select $OUTPUT[0] for each result as
# $OUTPUT[0] == ... == $OUTPUT[num_local_devices-1].
# After unshard(), result is of shape,
# [chunk, ...]
# Requires Assumption (4): Each device returns the same value.
# Requires Assumption (5): Output fits in RAM.
fine = jax.tree_map(lambda x: unshard(x[0], padding=padding), fine)
results.append(fine)
# pylint: enable=cell-var-from-loop
# Merge each list of ndarrays into one ndarray of shape [num_rays, ...].
# Signature: `tree_multimap(fn, *arrs: RenderedRays) -> RenderedRays`
# fn has signature `fn(*arrs: Array) -> Array`
results = jax.tree_multimap(
lambda *arrs: jnp.concatenate(arrs, axis=0),
*results,
)
# Reshape each ndarray to [height, width, num_channels].
results = jax.tree_map(lambda x: x.reshape(height, width, -1), results)
return results
def predict_3d_semantic(
render_pfn: Callable[..., f32["d D n k"]],
rng: j3d.RandomState,
sample_points: types.SamplePoints,
nerf_variables: Tree[jnp.ndarray],
nerf_sigma_grid: f32["1 x y z c"],
chunk: int,
num_semantic_classes: int,
) -> f32["N k"]:
"""Predict semantic categories for 3D points.
Args:
render_pfn: a function resulting from jax.pmap(f), where f returns the
result of an jax.lax.all_gather(). The arguments to this function must
be,
rng - jax.random.PRNGKey. Random key.
sample_points - types.SamplePoints. Points to predict semantics for.
batch_shape will be [d n k].
nerf_variables - Tree[jnp.ndarray]. NeRF variables.
nerf_sigma_grid - f32["1 x y z c"]. NeRF density grid.
The return value of this function's dimensions correspond to,
d - number of local devices
D - number of total devices
n - number of points per device
k - number of semantic categories
rng: Random number generator.
sample_points: Query points to predict semantic categories for. Batch
shape must be [N 1].
nerf_variables: NeRF variables for a single scene.
nerf_sigma_grid: NeRF sigma grid for a single scene.
chunk: maximum number of points per call to render_pfn.
num_semantic_classes: number of expected semantic classes.
Returns:
Semantic logits for all points in 'sample_points'.
"""
if not (len(sample_points.batch_shape) == 2 and
sample_points.batch_shape[-1] == 1):
raise ValueError(
f"sample_points must have exactly rank 3 (i.e. 2 batch dimensions). "
f"Expected batch shape: [N 1] "
f"Actual batch shape: {sample_points.batch_shape}")
# Helper functions for readability.
def pad_first_dimension(x, n):
padding = [(0, n)] + [(0, 0)] * (len(x.shape)-1)
return jnp.pad(x, padding, mode="edge")
num_points, _ = sample_points.batch_shape
process_index = jax.process_index()
results = []
for i in range(0, num_points, chunk):
# pylint: disable=cell-var-from-loop
# Split 'sample_points' into smaller, bite-sized bits that fit in device
# memory. Result is of shape,
# [chunk, ...]
chunk_sample_points: types.SamplePoints = (
jax.tree_map(lambda r: r[i:i+chunk], sample_points))
chunk_size = chunk_sample_points.batch_shape[0]
# Pad pseudo-examples at the end of this 'chunk_sample_points' to ensure
# that each device is operating on an ndarray of the same shape.
sample_points_remaining = chunk_size % jax.device_count()
if sample_points_remaining != 0:
padding = jax.device_count() - sample_points_remaining
chunk_sample_points = jax.tree_map(
lambda r: pad_first_dimension(r, padding),
chunk_sample_points)
else:
padding = 0
# After padding the number of chunk_sample_points is always divisible by
# process_count.
sample_points_per_process = (
chunk_sample_points.batch_shape[0] // jax.process_count())
# Identify the subset of 'chunk_sample_points' that this host is
# responsible for. If each host is processing the same value for
# 'chunk_sample_points', then we can reconstruct the full
# 'render_pfn(chunk_sample_points)' at the end.
start = process_index * sample_points_per_process
stop = start + sample_points_per_process
# Reshape chunk_sample_points to shape,
# [num_local_devices, batch_size_per_device, ...]
chunk_sample_points = jax.tree_map(lambda r: shard(r[start:stop]),
chunk_sample_points)
# Apply inference function. Result is of shape,
# [num_local_devices, num_total_devices, batch_size_per_device, ...]
predictions = render_pfn(rng.next(), chunk_sample_points,
nerf_variables, nerf_sigma_grid)
# Undo sharding operation. We select $OUTPUT[0] for each result as
# $OUTPUT[0] == ... == $OUTPUT[num_local_devices-1].
# After unshard(), result is of shape,
# [chunk, ...]
predictions = jax.tree_map(lambda x: unshard(x[0], padding=padding),
predictions)
results.append(predictions)
# pylint: enable=cell-var-from-loop
# In case there aren't any points to render, return something of a meaningful
# shape.
if not results:
return jnp.zeros((0, num_semantic_classes))
# Merge each list of ndarray into one ndarray of shape
# [num_sample_points, ...].
results = jax.tree_multimap(lambda *arrs: jnp.concatenate(arrs, axis=0),
*results)
return results
def save_img(img, path: PathLike):
"""Save an image to disk.
Note clipping and rescaling is only performed if the image type is float.
Otherwise the image is saved to disk as is.
Args:
img: jnp.ndarry, [height, width, channels], float32 images will be clipped
to [0, 1] before saved to path.
path: string, path to save the image to.
"""
with j3d.Path(path).open("wb") as imgout:
if img.dtype == np.float32:
img = np.array((np.clip(img, 0., 1.) * 255.).astype(jnp.uint8))
else:
img = np.array(img)
assert np.amax(img) <= 255, f"Saved image has max {np.amax(img)} > 255."
Image.fromarray(img).save(imgout, format="PNG")
def learning_rate_decay(step,
lr_init,
lr_final,
max_steps,
lr_delay_steps=0,
lr_delay_mult=1):
"""Continuous learning rate decay function.
The returned rate is lr_init when step=0 and lr_final when step=max_steps, and
is log-linearly interpolated elsewhere (equivalent to exponential decay).
If lr_delay_steps>0 then the learning rate will be scaled by some smooth
function of lr_delay_mult, such that the initial learning rate is
lr_init*lr_delay_mult at the beginning of optimization but will be eased back
to the normal learning rate when steps>lr_delay_steps.
Args:
step: int, the current optimization step.
lr_init: float, the initial learning rate.
lr_final: float, the final learning rate.
max_steps: int, the number of steps during optimization.
lr_delay_steps: int, the number of steps to delay the full learning rate.
lr_delay_mult: float, the multiplier on the rate when delaying it.
Returns:
lr: the learning for current step 'step'.
"""
if lr_delay_steps > 0:
# A kind of reverse cosine decay.
delay_rate = lr_delay_mult + (1 - lr_delay_mult) * np.sin(
0.5 * np.pi * | np.clip(step / lr_delay_steps, 0, 1) | numpy.clip |
import sys
import pygame
import numpy as np
from pygame.locals import *
from random import randint
class GameOfLife:
def __init__(self):
pygame.display.set_caption("Game of Life")
pygame.init()
pygame.mixer.quit()
self.font = pygame.font.SysFont("Arial", 18)
self.fps = 60
self.pause = False
self.screen_width = 600
self.screen_height = 600
self.grid_size = 10
self.grid_x_size = int(self.screen_width / self.grid_size)
self.grid_y_size = int(self.screen_height / self.grid_size)
self.grid = np.zeros((self.grid_x_size, self.grid_y_size))
self.screen = pygame.display.set_mode((self.screen_width, self.screen_height))
self.clock = pygame.time.Clock()
self.cell_skin = pygame.Surface((self.grid_size, self.grid_size))
self.cell_skin.fill((255, 255, 255))
self.initial_conditions()
def initial_conditions(self):
self.grid = np.random.randint(2, size=(self.grid_x_size, self.grid_y_size))
def on_grid_random(self):
x = randint(0, self.screen_width - self.grid_size)
y = randint(0, self.screen_height - self.grid_size)
return (x//self.grid_size * self.grid_size, y//self.grid_size * self.grid_size)
def check_alive(self, position, current_state):
alive_neighbors = self.check_neighborhood(position)
if alive_neighbors < 2 or alive_neighbors > 3:
return 0
elif alive_neighbors == 3:
return 1
return current_state
def check_neighborhood(self, position, radius=1):
filter_size = 2 * radius + 1
filter_matrix = np.ones((filter_size, filter_size))
filter_matrix[radius][radius] = 0
alive_cells = 0
for pos, filter_value in | np.ndenumerate(filter_matrix) | numpy.ndenumerate |
# -*- coding: UTF-8 -*-
import math
import pymatgen as mg
from ase.utils import gcd, basestring
from ase.build import bulk
from copy import deepcopy
from numpy.linalg import norm, solve
from pymatgen.analysis.graphs import MoleculeGraph, StructureGraph
from pymatgen.core.structure import Molecule
from pymatgen.io.vasp.inputs import Poscar
from ase import io
import networkx.algorithms.isomorphism as iso
import numpy as np
import networkx as nx
from pymatgen.core.lattice import Lattice
from pymatgen.core.sites import PeriodicSite
# used for deciding which atoms are bonded
from pymatgen.analysis.local_env import JmolNN
import os
import sys
import time
from functools import wraps
from collections import Counter
def from_ASE_to_pymatgen(working_dir, images):
"""
change ASE structure to pymatgen structure
"""
file_name = working_dir + "/temp.POSCAR.vasp"
io.write(file_name, images)
modify_poscar(file_name)
slab = mg.Structure.from_file(file_name)
os.remove(file_name)
return slab
def modify_poscar(file):
"""
Change the file to compliant POSCAR.
"""
index = 0
prev_file = open(file, 'r')
new_file = open(file+'.new', 'w')
for line in prev_file:
if index == 0:
tmp = line
new_file.write('slab\n')
elif index == 5:
#new_file.write(tmp)
new_file.write(line)
else:
new_file.write(line)
index = index+1
prev_file.close()
new_file.close()
os.remove(file)
os.rename(file+'.new', file)
def surface(lattice, indices, layers, tol=1e-10, termination=0):
"""Create surface from a given lattice and Miller indices.
lattice: Atoms object or str
Bulk lattice structure of alloy or pure metal. Note that the
unit-cell must be the conventional cell - not the primitive cell.
One can also give the chemical symbol as a string, in which case the
correct bulk lattice will be generated automatically.
indices: sequence of three int
Surface normal in Miller indices (h,k,l).
layers: int
Number of equivalent layers of the slab.
termination: int
The termination "number" for your crystal. The same value will not
produce the same termination for different symetrically identical
bulk structures, but changing this value allows your to explore all
the possible terminations for the bulk structure you provide it.
note: this code is not well tested
"""
indices = np.asarray(indices)
if indices.shape != (3,) or not indices.any() or indices.dtype != int:
raise ValueError('%s is an invalid surface type' % indices)
if isinstance(lattice, basestring):
lattice = bulk(lattice, cubic=True)
h, k, l = indices
h0, k0, l0 = (indices == 0)
if termination != 0: # changing termination
import warnings
warnings.warn('Work on changing terminations is currently in '
'progress. Code may not behave as expected.')
lattice1 = deepcopy(lattice)
cell = lattice1.get_cell()
pt = [0, 0, 0]
millers = list(indices)
for index, item in enumerate(millers):
if item == 0:
millers[index] = 10 ** 9 # make zeros large numbers
elif pt == [0, 0, 0]: # for numerical stability
pt = list(cell[index] / float(item) /
np.linalg.norm(cell[index]))
h1, k1, l1 = millers
N = np.array(cell[0] / h1 + cell[1] / k1 + cell[2] / l1)
n = N / np.linalg.norm(N) # making a unit vector normal to cut plane
d = [np.round(np.dot(n, (a - pt)), 4)
for a in lattice.get_scaled_positions()]
d = set(d)
d = sorted(list(d))
d = [0] + d # distances of atoms from cut plane
displacement = (h * cell[0] + k * cell[1] +
l * cell[2]) * d[termination]
lattice1.positions += displacement
lattice = lattice1
if h0 and k0 or h0 and l0 or k0 and l0: # if two indices are zero
if not h0:
c1, c2, c3 = [(0, 1, 0), (0, 0, 1), (1, 0, 0)]
if not k0:
c1, c2, c3 = [(0, 0, 1), (1, 0, 0), (0, 1, 0)]
if not l0:
c1, c2, c3 = [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
else:
p, q = ext_gcd(k, l)
a1, a2, a3 = lattice.cell
# constants describing the dot product of basis c1 and c2:
# dot(c1,c2) = k1+i*k2, i in Z
k1 = np.dot(p * (k * a1 - h * a2) + q * (l * a1 - h * a3),
l * a2 - k * a3)
k2 = np.dot(l * (k * a1 - h * a2) - k * (l * a1 - h * a3),
l * a2 - k * a3)
if abs(k2) > tol:
i = -int(round(k1 / k2)) # i corresponding to the optimal basis
p, q = p + i * l, q - i * k
a, b = ext_gcd(p * k + q * l, h)
c1 = (p * k + q * l, -p * h, -q * h)
c2 = np.array((0, l, -k)) // abs(gcd(l, k))
c3 = (b, a * p, a * q)
surf = build(lattice, np.array([c1, c2, c3]), layers, tol)
return surf
def ext_gcd(a, b):
"""
Extended Euclidean Algorithm. Find the result for ax + by = gcd(a, b).
Parameters
----------
a: int
b: int
"""
if b == 0:
return 1, 0
elif a % b == 0:
return 0, 1
else:
x, y = ext_gcd(b, a % b)
return y, x - y * (a // b)
def build(lattice, basis, layers, tol):
"""
Transform the structure to original surface based on basis.
Parameters
----------
basis: 3 * 3 matrix, [[a, b, c], ...]
the basis vectors of the target surfaces.
lattice: Atoms object or str
Bulk lattice structure of alloy or pure metal. Note that the
unit-cell must be the conventional cell - not the primitive cell.
One can also give the chemical symbol as a string, in which case the
correct bulk lattice will be generated automatically.
layers: int
Number of equivalent layers of the slab.
"""
surf = lattice.copy()
scaled = solve(basis.T, surf.get_scaled_positions().T).T
scaled -= np.floor(scaled + tol)
surf.set_scaled_positions(scaled)
surf.set_cell(np.dot(basis, surf.cell), scale_atoms=True)
surf *= (1, 1, layers)
return surf
def modify_cell(structure):
"""
This is the final step of a molecular reconstruction step, and would
align z direction to be perpendicular to the surface
Parameters
---------
structure: Atoms object or str
In this structure, the z direction might not be perpendicular to the
target surface.
"""
slab = structure.copy()
a1, a2, a3 = slab.cell
slab.set_cell([a1, a2,
np.cross(a1, a2) * np.dot(a3, np.cross(a1, a2)) /
norm(np.cross(a1, a2)) ** 2])
# Change unit cell to have the x-axis parallel with a surface vector
# and z perpendicular to the surface:
a1, a2, a3 = slab.cell
slab.set_cell([(norm(a1), 0, 0),
(np.dot(a1, a2) / norm(a1),
np.sqrt(norm(a2) ** 2 - (np.dot(a1, a2) / norm(a1)) ** 2), 0),
(0, 0, norm(a3))],
scale_atoms=True)
slab.pbc = (True, True, False)
scaled = slab.get_scaled_positions()
scaled[:, :2] %= 1
slab.set_scaled_positions(scaled)
return slab
def handle_with_molecules(slab_move, delta, down=True):
"""
Move some very tiny fragments of broken molecule to the other side. This is
a preparation step for the move_method, which could minimize the limitations.
Parameters
----------
slab_move: Atoms structure
slab_move is the original surfaces that is generated by ase library.
delta: list of double, [delta_x, delta_y, delta_z]
Add or subtract the delta (cart_coords) to the tiny broken molecules to
initially repair parts of molecules.
down: bool
True: Add a delta to the tiny broken molecules that are located at the bottom,
False: subtract a delta to the tiny broken molecules that are located at the top.
"""
slab_sg = StructureGraph.with_local_env_strategy(slab_move, JmolNN())
slab_supercell_sg = slab_sg * (3, 3, 1)
slab_sg_graph = nx.Graph(slab_supercell_sg.graph)
all_super_subgraphs = list(nx.connected_component_subgraphs
(slab_sg_graph))
super_subgraphs = []
for subgraph in all_super_subgraphs:
intersects_boundary = any([d['to_jimage'] != (0, 0, 0)
for u, v, d in subgraph.edges(data=True)])
if not intersects_boundary:
super_subgraphs.append(subgraph)
for subgraph in super_subgraphs:
for n in subgraph:
subgraph.add_node(n,
specie=str(slab_supercell_sg.structure[n].specie))
molecules = []
for subgraph in super_subgraphs:
coords = [slab_supercell_sg.structure[n].coords
for n in subgraph.nodes()]
# get the frac_cood of every atom for every molecules
coord_z_list = [slab_move.lattice.get_fractional_coords(
coord)[-1] for coord in coords]
if down is True:
temp = [coord_z < 0.5 for coord_z in coord_z_list]
else:
temp = [coord_z > 0.5 for coord_z in coord_z_list]
if not all(temp) or len(coords) > 6:
continue
species = [slab_supercell_sg.structure[n].specie
for n in subgraph.nodes()]
molecule = mg.Molecule(species=species, coords=coords)
molecules.append(molecule)
# molecules are the list of molecules that need to be moved
move_list = []
move_sites = reduced_sites(molecules, slab_move)
for move_site in move_sites:
for i, atom in enumerate(slab_move):
if atom.is_periodic_image(move_site):
move_list.append(i)
break
coords_move = slab_move.cart_coords
species_move = slab_move.species
slab_move.remove_sites(move_list)
for i in move_list:
if down is True:
new_coord = np.array(coords_move[i]) + np.array(delta)
else:
new_coord = np.array(coords_move[i]) - np.array(delta)
slab_move.append(species_move[i], new_coord, coords_are_cartesian=True)
return slab_move
def Find_Broken_Molecules(slab, sg, species_intact, coords_intact, unique_bulk_subgraphs):
"""
Use molecular identification method to find those molecules in the surface
that are different from that in the bulk.
Parameters
----------
slab: Atoms structure
The surface that is generated by ase library and might have broken molecules.
sg: list of Molecules
Unique Molecules in bulk Structure.
species_intact: list, ['specie_1', 'specie_2', ...]
A list of atomic species of intact molecules.
coords_intact: list, [[coord_1_1, coord_1_2, coord_1_3], ...]
A list of atomic cart_coords of intact molecules.
unique_bulk_subgraphs: list of graphs
A list of intact molecules' graphs. Note that every graph is this list
is unique
"""
slab_sg = StructureGraph.with_local_env_strategy(slab, JmolNN())
# enlarge the cell to a (3 * 3 * 1) super_cell
slab_supercell_sg = slab_sg * (3, 3, 1)
different_subgraphs_in_slab, slab_molecules = \
get_slab_different_subgraphs(slab_supercell_sg, unique_bulk_subgraphs)
slab_molecules = double_screen(slab_molecules, sg)
# the molecules in slab_original would be the template
#print("The number of molecules that need to be fixed : " +
# str(len(slab_molecules)))
# slab_molecules are the molecules that are broken and need to be fixed
delete_sites = reduced_sites(slab_molecules, slab)
# delete_list is the list of broken atoms
delete_list = []
for delete_site in delete_sites:
for i, atom in enumerate(slab):
if atom.is_periodic_image(delete_site):
delete_list.append(i)
break
species_all = slab.species
coords_all = slab.cart_coords
for i, atom in enumerate(slab):
temp = [i == delete for delete in delete_list]
if not any(temp):
species_intact.append(species_all[i])
coords_intact.append(coords_all[i])
delete_list = []
# remove intact molecules in the slab for convenience
#print("Delete all atoms!")
for i, atom in enumerate(slab):
delete_list.append(i)
slab.remove_sites(delete_list)
sites = []
for slab_molecule in slab_molecules:
for curr_site in slab_molecule:
curr_site = mg.PeriodicSite(curr_site.specie,
curr_site.coords,
slab.lattice,
coords_are_cartesian=True)
tmp = [curr_site.is_periodic_image(site) for site in sites]
if not any(tmp):
sites.append(curr_site)
for site in sites:
# add the broken molecules into the system
slab.append(species=site.specie, coords=site.coords,
coords_are_cartesian=True)
return slab
def get_broken_molecules(self, bulk_subgraphs, use_weights=False):
# compare each molecule in slab to each molecule in the bulk,
# get rid of isomorohic, molecules store the brokens
"""
Retrieve broken_subgraphs as molecules
Will return nonunique molecules, duplicates
present in the crystal (a duplicate defined as an
isomorphic subgraph).
Returns:
-------
: list of nonunique broken Molecules in Structure
"""
# creating a supercell is an easy way to extract
# molecules (and not, e.g., layers of a 2D crystal)
# without adding extra logic
supercell_sg = self*(3, 3, 1)
# make undirected to find connected subgraphs
supercell_sg.graph = nx.Graph(supercell_sg.graph)
# find subgraphs
all_subgraphs = list(nx.connected_component_subgraphs(supercell_sg.graph))
# discount subgraphs that lie across *supercell* boundaries
# these will subgraphs representing crystals
molecule_subgraphs = []
for subgraph in all_subgraphs:
intersects_boundary = any([d['to_jimage'] != (0, 0, 0)
for u, v, d in subgraph.edges(data=True)])
if not intersects_boundary:
molecule_subgraphs.append(subgraph)
# add specie names to graph to be able to test for isomorphism
for subgraph in molecule_subgraphs:
for n in subgraph:
subgraph.add_node(n, specie=str(supercell_sg.structure[n].specie))
# now define how we test for isomorphism
def node_match(n1, n2):
return n1['specie'] == n2['specie']
def edge_match(e1, e2):
if use_weights:
return e1['weight'] == e2['weight']
else:
return True
nm = iso.categorical_node_match("specie", "ERROR")
# remove complete molecules in subgraphs
different_subgraphs = []
start = time.time()
for subgraph in molecule_subgraphs:
already_present = [nx.is_isomorphic(subgraph, g,
node_match=nm)
for g in bulk_subgraphs]
if not any(already_present):
different_subgraphs.append(subgraph)
# get Molecule objects for each subgraph
molecules = []
for subgraph in different_subgraphs:
coords = [supercell_sg.structure[n].coords for n
in subgraph.nodes()]
species = [supercell_sg.structure[n].specie for n
in subgraph.nodes()]
molecule = Molecule(species, coords)
# shift so origin is at center of mass
#molecule = molecule.get_centered_molecule()
molecules.append(molecule)
return molecules
# now define how we test for isomorphism
def node_match(n1, n2):
"""the strategy for node matching in is_isomorphic.
Parameters
------
n1, n2 : node
Returns:
-------
True of false : bool
based on whether the species of two nodes are the same.
"""
return n1['specie'] == n2['specie']
def get_bulk_molecules(self, use_weights=False):
# get rid of the repetitve molecule in bulk, only left with unique molecule######
"""
Retrieve subgraphs as molecules, useful for extracting
molecules from periodic crystals.
Will only return unique molecules, not any duplicates
present in the crystal (a duplicate defined as an
isomorphic subgraph).
Parameters:
------
use_weights: (bool) If True, only treat subgraphs
as isomorphic if edges have the same weights. Typically,
this means molecules will need to have the same bond
lengths to be defined as duplicates, otherwise bond
lengths can differ. This is a fairly robust approach,
but will treat e.g. enantiomers as being duplicates.
Returns:
-------
list of unique Molecules in Structure
"""
# creating a supercell is an easy way to extract
# molecules (and not, e.g., layers of a 2D crystal)
# without adding extra logic
# enlarge the structureGraph object to a supercell
supercell_sg = self*(3, 3, 1)
# make undirected to find connected subgraphs
# create networkx undirected graph object to
supercell_sg.graph = nx.Graph(supercell_sg.graph)
# store the input graph
# find subgraphs
all_subgraphs = list(nx.connected_component_subgraphs(
supercell_sg.graph))
# add specie names to graph to be able to test for isomorphism
for subgraph in all_subgraphs:
for n in subgraph:
subgraph.add_node(n, specie=str(supercell_sg.structure[n].specie))
# now define how we test for isomorphism
def node_match(n1, n2):
return n1['specie'] == n2['specie']
def edge_match(e1, e2):
if use_weights:
return e1['weight'] == e2['weight']
else:
return True
nm = iso.categorical_node_match("specie", "ERROR")
# prune duplicate subgraphs
unique_subgraphs = []
for subgraph in all_subgraphs:
already_present = [nx.is_isomorphic(subgraph, g,
node_match=node_match,
edge_match=edge_match)
for g in unique_subgraphs]
if not any(already_present):
unique_subgraphs.append(subgraph)
# get Molecule objects for each subgraph
molecules = []
for subgraph in unique_subgraphs:
coords = [supercell_sg.structure[n].coords for n
in subgraph.nodes()]
species = [supercell_sg.structure[n].specie for n
in subgraph.nodes()]
molecule = Molecule(species, coords)
molecules.append(molecule)
return molecules, unique_subgraphs
#################convert to undirected mx.graph and then determine if isomorphic###############
def isomorphic_to(self, other):
"""
Checks if the graphs of two MoleculeGraphs are isomorphic to one
another. In order to prevent problems with misdirected edges, both
graphs are converted into undirected nx.Graph objects.
Parameters:
----------
other: MoleculeGraph object to be compared.
Returns:
-------
bool
"""
if self.molecule.composition != other.molecule.composition:
return False
else:
self_undir = self.graph.to_undirected()
other_undir = other.graph.to_undirected()
nm = iso.categorical_node_match("specie", "ERROR")
isomorphic = nx.is_isomorphic(self_undir, other_undir, node_match=nm)
return isomorphic
def reduced_sites(molecules, slab):
"""
Find atoms that appear again due to the periodicity.
Parameters:
-----------
molecules: List[molecule].
All molecules that might be within or out of the slab boundary.
slab: ASE structure.
Slab structure.
Returns:
--------
sites: List[atom].
"""
sites = []
for molecule in molecules:
for curr_site in molecule:
curr_site = PeriodicSite(
curr_site.specie, curr_site.coords, slab.lattice, coords_are_cartesian=True)
tmp = [curr_site.is_periodic_image(site) for site in sites]
if not any(tmp):
sites.append(curr_site)
return sites
def is_isomorphic(molecule1, molecule2):
"""
Determin whether two molecules are the same.
Parameters:
-----------
molecule1 and molecule2.
Returns:
--------
bool.
"""
return isomorphic_to(MoleculeGraph.with_local_env_strategy(molecule1, JmolNN()), MoleculeGraph.with_local_env_strategy(molecule2, JmolNN()))
def double_screen(slab_molecules, bulk_molecules):
"""
Double check with bulk if there is any molecule already present in bulk
"""
delete_list = []
for bulk_molecule in bulk_molecules:
for i, slab_molecule in enumerate(slab_molecules):
if is_isomorphic(bulk_molecule, slab_molecule):
delete_list.append(i)
tmp = [x for i, x in enumerate(slab_molecules) if i not in delete_list]
return tmp
def print_run_time(func):
"""
One wrapper that output the run_time of a funtion.
"""
@wraps(func)
def wrapper(*args, **kw):
local_time = time.time()
func(*args, **kw)
print('Current Function [%s] run time is %.2fs' %
(func.__name__, time.time() - local_time))
return wrapper
def updatePOSCAR(output_file):
"""This function is used to correct the output file (POSCAR) of ase.
Parameters:
----------
output_file : str
The file of surface written by the write function of ase.
Returns:
-------
file : str
The file that is corrected.
"""
with open(output_file, 'r') as original_file:
lines = original_file.readlines()
line1 = lines[0]
lines.insert(5, " " + line1)
with open(output_file, 'w') as final_file_1:
for i in range(len(lines)):
final_file_1.writelines(lines[i])
structure = mg.Structure.from_file(output_file)
lattice = Lattice(structure.lattice.matrix)
frac_coords = lattice.get_fractional_coords(structure.cart_coords)
for i in range(frac_coords.shape[0]):
for j in range(frac_coords.shape[1]):
if abs(frac_coords[i][j] - 1) < 1e-5:
frac_coords[i][j] = 1
if abs(frac_coords[i][j] - 0) < 1e-5:
frac_coords[i][j] = 0
with open(output_file, 'r') as final_file_2:
lines = final_file_2.readlines()
lines[7] = 'Direct' + '\n'
for i in range(np.array(frac_coords).shape[0]):
lines[8 + i] = " " + str(np.array(frac_coords)[i, :][0]) + ' ' + str(np.array(frac_coords)[i, :][1]) +\
' ' + str(np.array(frac_coords)[i, :][2]) + '\n'
with open(output_file, 'w') as final_file:
for i in range(len(lines)):
final_file.writelines(lines[i])
def edge_match(e1, e2):
"""the strategy for edge matching in is_isomorphic.
Parameters:
----------
e1, e2 : edge).
Returns:
-------
True or false : bool
based on whether the length of bonds are the same or close to each other.
"""
return abs(e1['weight'] - e2['weight']) / e2['weight'] < 1e-5
def get_bulk_subgraphs(bulk_structure_sg):
"""
Get all subgraphs of molecules that within or crosses the boundary of
original bulk.
Parameters:
-----------
bulk_structure_sg: StructureGraph.
The structure graph of bulk with local env strategy.
Returns:
--------
super_graphs : List[graph].
Represent the subgraphs of molecules that within or crosses the
boundary of original bulk.
molecules : List[molecule].
Molecules that are correlated to the subgraphs.
"""
bulk_super_structure_sg_graph = nx.Graph(bulk_structure_sg.graph)
all_super_subgraphs = list(nx.connected_component_subgraphs
(bulk_super_structure_sg_graph))
super_subgraphs = []
for subgraph in all_super_subgraphs:
in_boundary = any([d['to_jimage'] == (0, 0, 0)
for u, v, d in subgraph.edges(data=True)])
if in_boundary:
super_subgraphs.append(subgraph)
for subgraph in super_subgraphs:
for n in subgraph:
subgraph.add_node(n,
specie=str(bulk_structure_sg.structure[n].specie))
for subgraph in super_subgraphs:
if len(subgraph) == 1 and "H" in [str(bulk_structure_sg.structure[n].specie) for n in subgraph.nodes()]:
super_subgraphs.remove(subgraph)
continue
molecules = []
for subgraph in super_subgraphs:
coords = [bulk_structure_sg.structure[n].coords
for n in subgraph.nodes()]
species = [bulk_structure_sg.structure[n].specie
for n in subgraph.nodes()]
molecule = mg.Molecule(species=species, coords=coords)
molecules.append(molecule)
return super_subgraphs, molecules
def get_bulk_subgraphs_v2(bulk_structure_sg):
"""
Get all subgraphs of molecules that within or crosses the boundary of
original bulk.
Parameters:
-----------
bulk_structure_sg: StructureGraph.
The structure graph of bulk with local env strategy.
Returns:
--------
super_graphs : List[graph].
Represent the subgraphs of molecules that within or crosses the
boundary of original bulk.
molecules : List[molecule].
Molecules that are correlated to the subgraphs.
"""
bulk_super_structure_sg_graph = nx.Graph(bulk_structure_sg.graph)
all_super_subgraphs = list(nx.connected_component_subgraphs
(bulk_super_structure_sg_graph))
for subgraph in all_super_subgraphs:
for n in subgraph:
subgraph.add_node(n,
specie=str(bulk_structure_sg.structure[n].specie))
molecules = []
for subgraph in all_super_subgraphs:
coords = [bulk_structure_sg.structure[n].coords
for n in subgraph.nodes()]
species = [bulk_structure_sg.structure[n].specie
for n in subgraph.nodes()]
molecule = mg.Molecule(species=species, coords=coords)
molecules.append(molecule)
return all_super_subgraphs, molecules
def get_bulk_subgraphs_v3(slab_first, bulk_structure_sg):
"""
Get all subgraphs of molecules that within or crosses the boundary of
original bulk and generate HashGraph to modify atoms' positions.
Parameters:
-----------
slab_first: pymatgen structure.
Original slab structure that cleaved by ASE
bulk_structure_sg: StructureGraph.
The structure graph of bulk with local env strategy.
Returns:
--------
delta_cart: List[float].
c_difference between two adajacent layers.
super_graphs : List[graph].
Represent the subgraphs of molecules that within or crosses the
boundary of original bulk.
molecules : List[molecule].
Molecules that are correlated to the subgraphs.
"""
bulk_super_structure_sg_graph = nx.Graph(bulk_structure_sg.graph)
all_super_subgraphs = list(nx.connected_component_subgraphs
(bulk_super_structure_sg_graph))
for subgraph in all_super_subgraphs:
for n in subgraph:
subgraph.add_node(n,
specie=str(bulk_structure_sg.structure[n].specie))
frac_coods = [0] * len(bulk_structure_sg.structure)
initial_index = -100
molecules = []
for subgraph in all_super_subgraphs:
HashGraph = {}
for u, v, d in subgraph.edges(data=True):
change_z = list(d['to_jimage'])[-1]
if change_z != 0:
change_z = 1 if slab_first.lattice.get_fractional_coords(bulk_structure_sg.structure[u].coords)[-1] > slab_first.lattice.get_fractional_coords(bulk_structure_sg.structure[v].coords)[-1] else -1
try:
HashGraph[str(u)].append([str(v), change_z])
except KeyError:
HashGraph[str(u)] = [initial_index, [str(v), change_z]]
try:
HashGraph[str(v)].append([str(u), -change_z])
except KeyError:
HashGraph[str(v)] = [initial_index, [str(u), -change_z]]
first_node = list(HashGraph.keys())[0]
count = 1
HashGraph[first_node][0] = 0
Pending_node = [first_node]
Pending_node_2 = []
while(count < len(list(HashGraph.keys()))):
for node in Pending_node:
for value in HashGraph[node][1: ]:
if HashGraph[value[0]][0] == initial_index:
count += 1
HashGraph[value[0]][0] = HashGraph[node][0] + value[1]
Pending_node_2.append(value[0])
Pending_node = deepcopy(Pending_node_2)
Pending_node_2 = []
# min_z = min([value[0] for value in HashGraph.values()])
min_z = int(Counter([value[0] for value in HashGraph.values()]).most_common(1)[0][0])
delta = np.array(slab_first.lattice.matrix[-1])
for key in HashGraph.keys():
HashGraph[key][0] -= min_z
coords = [bulk_structure_sg.structure[n].coords + delta * HashGraph[str(n)][0]
for n in subgraph.nodes()]
species = [bulk_structure_sg.structure[n].specie
for n in subgraph.nodes()]
molecule = mg.Molecule(species=species, coords=coords)
molecules.append(molecule)
return delta, all_super_subgraphs, molecules
def get_bulk_subgraphs_unique(bulk_structure_sg):
"""
get unique subgraphs of bulk based on graph algorithm.
This function would only return unique molecules and its graphs,
but not any duplicates present in the crystal.
(A duplicate defined as an isomorphic crystals.
Parameters:
-----------
bulk_structure_sg : nx.SturctureGraph class,
this one is actually the supercell one that is equal to(3, 3, 3) * unit cell.
Returns:
--------
unique_super_graphs : (list) [graph, ...],
represent the unique subgraphs in the supercell and expecially
in the boundary of supercell.
molecules : (list) [molecule, ...],
represent the molecules that are correlated to the unque subgraphs.
"""
bulk_super_structure_sg_graph = nx.Graph(bulk_structure_sg.graph)
all_super_subgraphs = list(nx.connected_component_subgraphs
(bulk_super_structure_sg_graph))
super_subgraphs = []
for subgraph in all_super_subgraphs:
intersects_boundary = any([d['to_jimage'] != (0, 0, 0)
for u, v, d in subgraph.edges(data=True)])
if not intersects_boundary:
super_subgraphs.append(subgraph)
for subgraph in super_subgraphs:
for n in subgraph:
subgraph.add_node(n,
specie=str(bulk_structure_sg.structure[n].specie))
unique_super_subgraphs = []
for subgraph in super_subgraphs:
if len(subgraph) == 1 and "H" in [str(bulk_structure_sg.structure[n].specie) for n in subgraph.nodes()]:
continue
already_present = [nx.is_isomorphic(subgraph, g,
node_match=node_match,
edge_match=edge_match)
for g in unique_super_subgraphs]
if not any(already_present):
unique_super_subgraphs.append(subgraph)
molecules = []
for subgraph in unique_super_subgraphs:
coords = [bulk_structure_sg.structure[n].coords
for n in subgraph.nodes()]
species = [bulk_structure_sg.structure[n].specie
for n in subgraph.nodes()]
molecule = mg.Molecule(species=species, coords=coords)
molecules.append(molecule)
return unique_super_subgraphs, molecules
def get_slab_different_subgraphs(slab_supercell_sg, unique_super_bulk_subgraphs):
"""this function is used to find all the subgraphs in slab that
are different from those in bulk.
Parameters:
----------
slab_supercell_sg : nx.StructureGraph,
the graph of the whole slabs.
Note: In order to thoughtoutly describe the graph,
the slab_supercell_sg = (3, 3, 1) * slab_sg
unique_super_bulk_subgraphs : list.
Returns:
-------
different_subgraphs : list
[different_subgraph, ...], which is the list of subgraphs that
are different from those in bulk. In this function,
we would only find the different subgraphs based on its species.
slab_molecules : list
[slab_molecule, ...], slab_molecule is the mg.Molecule of diffenert_subgraphs.
"""
slab_supercell_sg_graph = nx.Graph(slab_supercell_sg.graph)
all_subgraphs = list(nx.connected_component_subgraphs
(slab_supercell_sg_graph))
molecule_subgraphs = []
for subgraph in all_subgraphs:
intersets_boundary = any([d['to_jimage'] != (0, 0, 0)
for u, v, d in subgraph.edges(data=True)])
if not intersets_boundary:
molecule_subgraphs.append(subgraph)
#print("molecule_subgraphs : ", len(molecule_subgraphs))
for subgraph in molecule_subgraphs:
for n in subgraph:
subgraph.add_node(n, specie=str(
slab_supercell_sg.structure[n].specie))
nm = iso.categorical_node_match("specie", "ERROR")
different_subgraphs = []
for subgraph in molecule_subgraphs:
already_present = [nx.is_isomorphic(subgraph, g,
node_match=nm)
for g in unique_super_bulk_subgraphs]
if not any(already_present):
different_subgraphs.append(subgraph)
slab_molecules = []
for subgraph in different_subgraphs:
coords = [slab_supercell_sg.structure[n].coords
for n in subgraph.nodes()]
species = [slab_supercell_sg.structure[n].specie
for n in subgraph.nodes()]
molecule = mg.Molecule(species=species, coords=coords)
slab_molecules.append(molecule)
return different_subgraphs, slab_molecules
def belong_to(species1, species2):
"""
Determine whether species1 are totally included by species2.
"""
if len(species1) > len(species2):
return False
i = 0
species_1 = species1[:]
species_2 = species2[:]
while i < len(species_1):
find = False
for j in range(len(species_2)):
if species_1[i] == species_2[j]:
del species_1[i]
find = True
del species_2[j]
break
if find is False:
return False
return True
def length_belong_to(weights1, weights2):
"""
Determine whether weights1 are totally included by weights2
weights are the list [weight, weight, ...] of one node
"""
if len(weights1) > len(weights2):
return False
i = 0
weights_1 = weights1[:]
weights_2 = weights2[:]
while i < len(weights_1):
find = False
for j in range(len(weights_2)):
if abs((weights_1[i] - weights_2[j]) / weights_2[j]) < 1e-5:
del weights_1[i]
find = True
del weights_2[j]
break
if find is False:
return False
return True
def weights_all_belong_to(all_weight1, all_weight2, species1, species2):
"""
Determine whether one graph is totally included by another graph by
comparing species and weights.
"""
if len(all_weight1) > len(all_weight2):
return False
i = 0
account = 0
total = len(all_weight1)
all_weight_1 = all_weight1[:]
all_weight_2 = all_weight2[:]
species_1 = species1[:]
species_2 = species2[:]
while i < len(all_weight_1):
find = False
for j in range(len(all_weight_2)):
if length_belong_to(all_weight_1[i], all_weight_2[j]) and species_1[i] == species_2[j]:
del all_weight_1[i]
del species_1[i]
del species_2[j]
account += 1
del all_weight_2[j]
find = True
break
if not find:
i += 1
if account >= 2.0 / 3.0 * total:
return True
return False
def brokenMolecules_and_corresspoundingIntactMolecules(new_different_subgraphs,
unique_super_subgraphs):
"""
NOT used in current reconstruction method!!!
Determine the intact molecules that each molecule (broken or intact) belongs to by
compcomparing the species and weights of broken molecules and intact
molecules.
Parameters:
-----------
new_different_subgraphs: List[subgraph].
Subgraphs of all molecules.
unique_super_subgraphs: List[subgraph].
Subgraphs of all bulk's unique molecules.
Returns:
--------
qualified_subgraphs: List[subgraph].
List of subgraph of molecules in the raw slab.
unique_super_subgraphs: List[subgraph].
List of subgraph of corresspounding intact molecules. The length of
qualified_unique_subgraphs should be the same as the length of
qualified_subgraphs.
"""
qualified_subgraphs = []
qualified_unique_subgraphs = []
# account = 1
#print("trying to find the connection between broken molecules "
# "and intact molecules")
for subgraph in new_different_subgraphs:
subgraph_species = []
weights_all = []
for n, nbrs in subgraph.adjacency():
subgraph_species.append(subgraph.node[n]['specie'])
weights = []
for nbr, eattr in nbrs.items():
weights.append(eattr['weight'])
weights_all.append(weights)
find = False
for unique_subgraph in unique_super_subgraphs:
unique_subgraph_species = []
unique_weights_all = []
for n, nbrs in unique_subgraph.adjacency():
unique_subgraph_species.append(
unique_subgraph.node[n]['specie'])
weights = []
for nbr, eattr in nbrs.items():
weights.append(eattr['weight'])
unique_weights_all.append(weights)
if not belong_to(subgraph_species, unique_subgraph_species):
continue
else:
if not weights_all_belong_to(weights_all, unique_weights_all,
subgraph_species,
unique_subgraph_species):
continue
else:
find = True
qualified_subgraphs.append(subgraph)
qualified_unique_subgraphs.append(unique_subgraph)
break
if find is False:
print("can't find the qualified subgraphs")
sys.exit()
return qualified_subgraphs, qualified_unique_subgraphs
def fix_broken_molecules(qualified_subgraphs,
qualified_unique_subgraphs,
bulk_super_structure_sg,
slab_supercell_sg,
slab, c_frac_min, fixed_c_negative=False):
"""
NOT used in the current reconstruction method!!!
Fix broken molecules based on graph theory. After determine the affiliation
between all molecules in raw slabs and intact molecules in the original
bulk, this function would replace those broken molecules with intact
molecules.
Parameters:
-----------
qualified_subgraphs: List[subgraph].
List of subgraphs of all molecules in the raw molecules.
qualified_unique_subgraphs: List[subgraph].
Each element in the list is the subgraph of corresspounding intact
molecule of "qualified_subgraphs" in the previous list.
bulk_super_structure_sg: StructureGraph.
Structure Graph of supercell (3 x 3 x 3) of original bulk.
slab_supercell_sg: StructureGraph.
Structure Graph of supercell (3 x 3 x 3) of raw slab.
slab: ASE structure.
Raw slab after ASE cleaving.
c_frac_min: float.
Fractional coordinate of the lowest atom in raw slabs in c direction.
fixed_c_negative: bool
Fix the broken molecules in the lower side or not? Default option is
False.
Returns:
--------
slab: pymatgen structure.
Slab after reconstruction.
"""
molecules_new = []
#print("trying to fix the broken molecules...")
for i in range(len(qualified_subgraphs)):
qualified_subgraphs_species = []
qualified_subgraphs_nodes_neibs = []
qualified_subgraphs_all_weights = []
nodes_qualified_subgraphs = []
for n, nbrs in qualified_subgraphs[i].adjacency():
nodes_qualified_subgraphs.append(n)
neibs = []
weights = []
qualified_subgraphs_species.append(
qualified_subgraphs[i].node[n]['specie'])
for nbr, eattr in nbrs.items():
neibs.append(nbr)
weights.append(eattr['weight'])
qualified_subgraphs_nodes_neibs.append(neibs)
qualified_subgraphs_all_weights.append(weights)
qualified_unique_subgraphs_species = []
qualified_unique_subgraphs_nodes_neibs = []
qualified_unique_subgraphs_all_weights = []
nodes_qualified_unique_subgraphs = []
for n, nbrs in qualified_unique_subgraphs[i].adjacency():
nodes_qualified_unique_subgraphs.append(n)
neibs = []
weights = []
qualified_unique_subgraphs_species.append(
qualified_unique_subgraphs[i].node[n]['specie'])
for nbr, eattr in nbrs.items():
neibs.append(nbr)
weights.append(eattr['weight'])
qualified_unique_subgraphs_all_weights.append(weights)
qualified_unique_subgraphs_nodes_neibs.append(neibs)
node1 = []
node2 = []
account = 0
for t in range(len(qualified_subgraphs_species)):
account = 0
for k in range(len(qualified_unique_subgraphs_species)):
account = 0
if qualified_subgraphs_species[t] == qualified_unique_subgraphs_species[k] \
and length_belong_to(qualified_subgraphs_all_weights[t],
qualified_unique_subgraphs_all_weights[k]) \
and len(qualified_subgraphs_all_weights[t]) == 3:
node1 = [nodes_qualified_subgraphs[t]]
node2 = [nodes_qualified_unique_subgraphs[k]]
account = 0
for a_index, a_weight in enumerate(qualified_subgraphs_all_weights[t]):
for index, weight in enumerate(qualified_unique_subgraphs_all_weights[k]):
has1 = qualified_subgraphs_nodes_neibs[t][a_index] in node1
has2 = qualified_unique_subgraphs_nodes_neibs[k][index] in node2
if abs(weight - a_weight) / weight < 1e-5 and has1 is False and has2 is False:
node1.append(
qualified_subgraphs_nodes_neibs[t][a_index])
node2.append(
qualified_unique_subgraphs_nodes_neibs[k][index])
account += 1
break
if account >= 3:
break
if account >= 3:
break
if account < 3:
print("can't find the corresspounding point")
sys.exit()
coords1 = [slab_supercell_sg.structure[n].coords for n in node1]
coords2 = [bulk_super_structure_sg.structure[n].coords for n in node2]
relative1 = np.array([np.array(coords1[n]) - np.array(coords1[0])
for n in list(range(1, 4))])
relative2 = np.array([np.array(coords2[n]) - np.array(coords2[0])
for n in list(range(1, 4))])
try:
rotationMatrix = np.dot(relative1.T, np.linalg.inv(relative2.T))
except np.linalg.LinAlgError as err:
if 'Singular matrix' in str(err):
for m in range(relative1.shape[0]):
if relative1[m, 0] == 0 and relative1[m, 1] == 0 and relative1[m, 2] == 0:
relative1[m, 0] = 1e-9
relative1[m, 2] = -1e-9
for m in range(relative1.shape[1]):
if relative1[0, m] == 0 and relative1[1, m] == 0 and relative1[2, m] == 0:
relative1[0, m] = 1e-9
relative1[2, m] = -1e-9
for m in range(relative2.shape[0]):
if relative2[m, 0] == 0 and relative2[m, 1] == 0 and relative2[m, 2] == 0:
relative2[m, 0] = 1e-9
relative2[m, 2] = -1e-9
for m in range(relative2.shape[1]):
if relative2[0, m] == 0 and relative2[1, m] == 0 and relative2[2, m] == 0:
relative2[0, m] = 1e-9
relative2[2, m] = -1e-9
rotationMatrix = np.dot(
relative1.T, np.linalg.inv(relative2.T))
else:
print('failed')
sys.exit()
relative = np.array([np.array(bulk_super_structure_sg.structure[n].coords)
- np.array(coords2[0])
for n in qualified_unique_subgraphs[i].nodes()])
new_relatives = np.dot(rotationMatrix, relative.T).T
coords = [np.array(coords1[0]) + new_relative
for new_relative in new_relatives]
species = [bulk_super_structure_sg.structure[n].specie
for n in qualified_unique_subgraphs[i].nodes()]
molecule = mg.Molecule(species=species, coords=coords)
molecules_new.append(molecule)
sites = []
molecules_new_backup = list(molecules_new)
if not fixed_c_negative:
i = 0
while i < len(molecules_new):
under = False
for curr_site in molecules_new[i]:
curr_site = mg.PeriodicSite(curr_site.specie,
curr_site.coords,
slab.lattice,
coords_are_cartesian=True)
if curr_site.frac_coords[2] < c_frac_min:
del molecules_new[i]
under = True
break
if under is False:
i += 1
if len(molecules_new) == 0:
molecules_new = molecules_new_backup
for molecule in molecules_new:
for curr_site in molecule:
curr_site = mg.PeriodicSite(curr_site.specie,
curr_site.coords,
slab.lattice,
coords_are_cartesian=True)
tmp = [curr_site.is_periodic_image(site) for site in sites]
if not any(tmp):
sites.append(curr_site)
for site in sites:
slab.append(species=site.specie, coords=site.coords,
coords_are_cartesian=True)
return slab
def put_everyatom_into_cell(slab):
"""
Some atoms might be out of the boundary of slab. Put all atoms into the
boundary in the case that atoms don't overlap.
"""
coords = slab.frac_coords
for i in range(coords.shape[0]):
for j in range(coords.shape[1]):
coords[i, j] = coords[i, j] % 1
species = slab.species
molecule = mg.Molecule(species, coords)
sites = []
for site in molecule:
site = mg.PeriodicSite(site.specie,
site.coords,
slab.lattice)
tmp = [site.is_periodic_image(item, tolerance=1e-5) for item in sites]
if not any(tmp):
sites.append(site)
delete_list = []
for i, atom in enumerate(slab):
delete_list.append(i)
slab.remove_sites(delete_list)
for site in sites:
slab.append(species=site.specie, coords=site.coords,
coords_are_cartesian=True)
return slab
def less_fix_broken_molecules(less_broken_subgraphs, less_intact_subgraphs,
bulk_super_structure_sg,
slab_supercell_sg,
slab, c_frac_min,
fixed_c_negative=True):
"""
NOT used in the current reconstruction method!!!
An optimized function of fix_broken_molecules() but does exactly the
same thing. It can deal with more small broken molecules.
"""
molecules_new = []
for i in range(len(less_broken_subgraphs)):
broken_subgraphs_species = []
broken_subgraphs_nodes_neibs = []
broken_subgraphs_weights = []
nodes_broken_subgraphs = []
for n, nbrs in less_broken_subgraphs[i].adjacency():
nodes_broken_subgraphs.append(n)
neibs = []
weights = []
broken_subgraphs_species.append(
less_broken_subgraphs[i].node[n]['specie'])
for nbr, eattr in nbrs.items():
neibs.append(nbr)
weights.append(eattr['weight'])
broken_subgraphs_nodes_neibs.append(neibs)
broken_subgraphs_weights.append(weights)
intact_subgraphs_species = []
intact_subgraphs_nodes_neibs = []
intact_subgraphs_weights = []
nodes_intact_subgraphs = []
for n, nbrs in less_intact_subgraphs[i].adjacency():
nodes_intact_subgraphs.append(n)
neibs = []
weights = []
intact_subgraphs_species.append(
less_intact_subgraphs[i].node[n]['specie'])
for nbr, eattr in nbrs.items():
neibs.append(nbr)
weights.append(eattr['weight'])
intact_subgraphs_nodes_neibs.append(neibs)
intact_subgraphs_weights.append(weights)
Find = False
nodes1 = []
nodes2 = []
for j in range(len(broken_subgraphs_species)):
if len(broken_subgraphs_nodes_neibs[j]) == 2:
nodes1 = []
weights1 = []
nodes1.append(nodes_broken_subgraphs[j])
for index, neib in enumerate(broken_subgraphs_nodes_neibs[j]):
nodes1.append(neib)
weights1.append(broken_subgraphs_weights[j][index])
nodes2 = []
for k in range(len(intact_subgraphs_species)):
if broken_subgraphs_species[j] == intact_subgraphs_species[k]\
and length_belong_to(broken_subgraphs_weights[j], intact_subgraphs_weights[k]):
nodes2.append(nodes_intact_subgraphs[k])
for index, weight in enumerate(weights1):
for index_intact, weight_intact in enumerate(intact_subgraphs_weights[k]):
if abs(weight - weight_intact) / weight_intact < 1e-5\
and less_broken_subgraphs[i].\
node[nodes1[index + 1]]['specie'] == less_intact_subgraphs[i].\
node[intact_subgraphs_nodes_neibs[k][index_intact]]['specie']:
nodes2.append(
intact_subgraphs_nodes_neibs[k][index_intact])
if len(nodes2) == 3:
Find = True
break
if Find is True:
# print('Find it')
break
if Find is False:
#print("Sucks")
sys.exit()
rest_item = -1
rest_index = -1
for index, item in enumerate(nodes_broken_subgraphs):
if item not in nodes1:
rest_item = item
rest_index = index
nodes1.append(rest_item)
Find = False
for j in range(len(intact_subgraphs_species)):
if intact_subgraphs_species[j] == broken_subgraphs_species[rest_index]\
and length_belong_to(broken_subgraphs_weights[rest_index], intact_subgraphs_weights[j]):
neibs = intact_subgraphs_nodes_neibs[j]
temp = [neib == node2 for neib in neibs for node2 in nodes2]
if any(temp):
nodes2.append(nodes_intact_subgraphs[j])
Find = True
break
if Find is not True:
print("didn't find the fourth one!")
sys.exit()
node1, node2 = nodes1, nodes2
coords1 = [slab_supercell_sg.structure[n].coords for n in node1]
coords2 = [bulk_super_structure_sg.structure[n].coords for n in node2]
relative1 = np.array([np.array(coords1[n]) - np.array(coords1[0])
for n in list(range(1, 4))])
relative2 = np.array([np.array(coords2[n]) - np.array(coords2[0])
for n in list(range(1, 4))])
try:
rotationMatrix = np.dot(relative1.T, np.linalg.inv(relative2.T))
except np.linalg.LinAlgError as err:
if 'Singular matrix' in str(err):
for m in range(relative1.shape[0]):
if relative1[m, 0] == 0 and relative1[m, 1] == 0 and relative1[m, 2] == 0:
relative1[m, 0] = 1e-9
relative1[m, 2] = -1e-9
for m in range(relative1.shape[1]):
if relative1[0, m] == 0 and relative1[1, m] == 0 and relative1[2, m] == 0:
relative1[0, m] = 1e-9
relative1[2, m] = -1e-9
for m in range(relative2.shape[0]):
if relative2[m, 0] == 0 and relative2[m, 1] == 0 and relative2[m, 2] == 0:
relative2[m, 0] = 1e-9
relative2[m, 2] = -1e-9
for m in range(relative2.shape[1]):
if relative2[0, m] == 0 and relative2[1, m] == 0 and relative2[2, m] == 0:
relative2[0, m] = 1e-9
relative2[2, m] = -1e-9
rotationMatrix = np.dot(
relative1.T, np.linalg.inv(relative2.T))
else:
print('failed')
sys.exit()
relative = np.array([np.array(bulk_super_structure_sg.structure[n].coords)
- np.array(coords2[0])
for n in less_intact_subgraphs[i].nodes()])
new_relatives = | np.dot(rotationMatrix, relative.T) | numpy.dot |
import code.book_plots as bp
import code.gh_internal as gh
import matplotlib.pyplot as plt
import numpy as np;
import time
from pylab import *
from drawnow import drawnow, figure
from filterpy.discrete_bayes import normalize
from filterpy.discrete_bayes import predict
from filterpy.discrete_bayes import update
from scipy.ndimage import measurements
import filterpy.stats as stats
from filterpy.stats import gaussian, multivariate_gaussian
from numpy.random import randn,seed
from code.DogSimulation import DogSimulation
from code import kf_internal
from filterpy.kalman import predict, update
from filterpy.kalman import KalmanFilter
from filterpy.common import Q_discrete_white_noise
from code.mkf_internal import plot_track
class Chapter06_25(object):
def __init__(self):
pass
def pos_vel_filter(self, x, P, R, Q=0., dt=1.0):
""" Returns a KalmanFilter which implements a
constant velocity model for a state [x dx].T
"""
kf = KalmanFilter(dim_x=2, dim_z=1)
kf.x = np.array([x[0], x[1]]) # location and velocity
kf.F = np.array([[1., dt],
[0., 1.]]) # state transition matrix
kf.H = np.array([[1., 0]]) # Measurement function
kf.R *= R # measurement uncertainty
if np.isscalar(P):
kf.P *= P # covariance matrix
else:
kf.P[:] = P # [:] makes deep copy
if np.isscalar(Q):
kf.Q = Q_discrete_white_noise(dim=2, dt=dt, var=Q)
else:
kf.Q[:] = Q
return kf
def compute_dog_data(self, z_var, process_var, count=1, dt=1.):
"returns track, measurements 1D ndarrays"
x, vel = 0., 1.
z_std = math.sqrt(z_var)
p_std = math.sqrt(process_var)
xs, zs = [], []
for _ in range(count):
v = vel + (randn() * p_std * dt)
x += v*dt
xs.append(x)
zs.append(x + randn() * z_std)
return np.array(xs), np.array(zs)
def draw_fig1(self):
plt.scatter(self.sc1X, self.sc1Y)
plt.scatter(self.sc2X,self.sc2Y)
def run(self,x0=(0.,0.), P=500, R=0, Q=0, dt=1.0,
track=None, zs=None,
count=0, do_plot=True, **kwargs):
"""
track is the actual position of the dog, zs are the
corresponding measurements.
"""
# Simulate dog if no data provided.
if zs is None:
track, zs = self.compute_dog_data(R, Q, count)
# create the Kalman filter
kf = self.pos_vel_filter(x0, R=R, P=P, Q=Q, dt=dt)
# run the kalman filter and store the results
xs, cov = [], []
for z in zs:
kf.predict()
kf.update(z)
xs.append(kf.x)
cov.append(kf.P)
xs, cov = np.array(xs), | np.array(cov) | numpy.array |
import helpers
import numpy
import pytest
import toughio
write_read = lambda x, **kwargs: helpers.write_read(
"INFILE", x, toughio.write_input, toughio.read_input, **kwargs
)
write_read_tough = lambda x: write_read(
x,
writer_kws={"file_format": "tough"},
reader_kws={"file_format": "tough"},
)
write_read_json = lambda x: write_read(
x,
writer_kws={"file_format": "json"},
reader_kws={"file_format": "json"},
)
@pytest.mark.parametrize(
"write_read, single",
[
(write_read_tough, True),
(write_read_tough, False),
(write_read_json, True),
(write_read_json, False),
],
)
def test_title(write_read, single):
parameters_ref = {
"title": (
helpers.random_string(80)
if single
else [helpers.random_string(80) for _ in range(numpy.random.randint(5) + 2)]
),
}
parameters = write_read(parameters_ref)
assert parameters_ref["title"] == parameters["title"]
@pytest.mark.parametrize("write_read", [write_read_tough, write_read_json])
def test_rocks(write_read):
keys = [
"density",
"porosity",
"permeability",
"conductivity",
"specific_heat",
"compressibility",
"expansivity",
"conductivity_dry",
"tortuosity",
"klinkenberg_parameter",
"distribution_coefficient_3",
"distribution_coefficient_4",
]
parameters_ref = {
"rocks": {
helpers.random_string(5): {key: numpy.random.rand() for key in keys[:5]},
helpers.random_string(5): {
key: numpy.random.rand()
if key != "permeability"
else numpy.random.rand(3)
for key in keys[:5]
},
helpers.random_string(5): {key: numpy.random.rand() for key in keys},
helpers.random_string(5): {key: numpy.random.rand() for key in keys},
helpers.random_string(5): {key: numpy.random.rand() for key in keys},
helpers.random_string(5): {key: numpy.random.rand() for key in keys},
}
}
names = list(parameters_ref["rocks"].keys())
parameters_ref["rocks"][names[-1]].update(
{
"relative_permeability": {
"id": numpy.random.randint(10),
"parameters": numpy.random.rand(numpy.random.randint(7) + 1),
},
}
)
parameters_ref["rocks"][names[-2]].update(
{
"capillarity": {
"id": numpy.random.randint(10),
"parameters": numpy.random.rand(numpy.random.randint(7) + 1),
},
}
)
parameters_ref["rocks"][names[-3]].update(
{
"relative_permeability": {
"id": numpy.random.randint(10),
"parameters": numpy.random.rand(numpy.random.randint(7) + 1),
},
"capillarity": {
"id": numpy.random.randint(10),
"parameters": numpy.random.rand(numpy.random.randint(7) + 1),
},
}
)
parameters = write_read(parameters_ref)
assert sorted(parameters_ref["rocks"].keys()) == sorted(parameters["rocks"].keys())
for k, v in parameters_ref["rocks"].items():
for kk, vv in v.items():
if not isinstance(vv, dict):
assert numpy.allclose(vv, parameters["rocks"][k][kk], atol=1.0e-5)
else:
helpers.allclose_dict(vv, parameters["rocks"][k][kk], atol=1.0e-4)
@pytest.mark.parametrize(
"write_read, rpcap",
[
(write_read_tough, "rp"),
(write_read_tough, "cap"),
(write_read_tough, "both"),
(write_read_json, "rp"),
(write_read_json, "cap"),
(write_read_json, "both"),
],
)
def test_rpcap(write_read, rpcap):
parameters_ref = {"default": {}}
if rpcap in {"rp", "both"}:
parameters_ref["default"]["relative_permeability"] = {
"id": numpy.random.randint(10),
"parameters": numpy.random.rand(numpy.random.randint(7) + 1),
}
if rpcap in {"cap", "both"}:
parameters_ref["default"]["capillarity"] = {
"id": numpy.random.randint(10),
"parameters": numpy.random.rand(numpy.random.randint(7) + 1),
}
parameters = write_read(parameters_ref)
for k, v in parameters_ref["default"].items():
helpers.allclose_dict(v, parameters["default"][k], atol=1.0e-4)
@pytest.mark.parametrize("write_read", [write_read_tough, write_read_json])
def test_flac(write_read):
parameters_ref = {
"flac": {
"creep": bool(numpy.random.randint(2)),
"porosity_model": numpy.random.randint(10),
"version": numpy.random.randint(10),
},
"rocks": {
helpers.random_string(5): {
"permeability_model": {
"id": numpy.random.randint(10),
"parameters": numpy.random.rand(numpy.random.randint(7) + 1),
},
"equivalent_pore_pressure": {
"id": numpy.random.randint(10),
"parameters": numpy.random.rand(numpy.random.randint(7) + 1),
},
}
for _ in numpy.random.rand(10) + 1
},
}
parameters = write_read(parameters_ref)
helpers.allclose_dict(parameters_ref["flac"], parameters["flac"])
for k, v in parameters_ref["rocks"].items():
for kk, vv in v.items():
helpers.allclose_dict(vv, parameters["rocks"][k][kk], atol=1.0e-4)
@pytest.mark.parametrize(
"write_read, isothermal",
[(write_read_tough, True), (write_read_tough, False)],
)
def test_multi(write_read, isothermal):
import random
from toughio._io.input.tough._common import eos
parameters_ref = {
"eos": random.choice(
[k for k in eos.keys() if k not in {"eos7", "eos8", "eos9"}]
),
"isothermal": isothermal,
}
parameters = write_read(parameters_ref)
multi = [
parameters["n_component"],
parameters["n_component"] + 1,
parameters["n_phase"],
6,
]
multi_ref = eos[parameters_ref["eos"]]
assert multi_ref == multi
assert parameters_ref["isothermal"] == parameters["isothermal"]
@pytest.mark.parametrize("write_read", [write_read_tough, write_read_json])
def test_solvr(write_read):
parameters_ref = {
"solver": {
"method": numpy.random.randint(10),
"z_precond": helpers.random_string(2),
"o_precond": helpers.random_string(2),
"rel_iter_max": numpy.random.rand(),
"eps": numpy.random.rand(),
},
}
parameters = write_read(parameters_ref)
assert parameters_ref["solver"]["method"] == parameters["solver"]["method"]
assert parameters_ref["solver"]["z_precond"] == parameters["solver"]["z_precond"]
assert parameters_ref["solver"]["o_precond"] == parameters["solver"]["o_precond"]
assert numpy.allclose(
parameters_ref["solver"]["rel_iter_max"],
parameters["solver"]["rel_iter_max"],
atol=1.0e-5,
)
assert numpy.allclose(
parameters_ref["solver"]["eps"], parameters["solver"]["eps"], atol=1.0e-5
)
@pytest.mark.parametrize(
"write_read, t_steps, num_pvars",
[
(write_read_tough, numpy.random.rand(), 4),
(write_read_tough, numpy.random.rand(numpy.random.randint(100) + 1), 4),
(write_read_tough, numpy.random.rand(numpy.random.randint(100) + 1), 6),
(write_read_json, numpy.random.rand(), 4),
(write_read_json, numpy.random.rand(numpy.random.randint(100) + 1), 4),
(write_read_json, numpy.random.rand( | numpy.random.randint(100) | numpy.random.randint |
"""
Solutions to the Cryptopals Crypto Challenge
All crypto functions take and return numpy arrays of uint8; convenience
functions are provided to convert to and from this format.
You will need the datafiles from the challenges to run the tests.
"""
from base64 import b64encode as base64_encode
from base64 import b64decode as base64_decode
from base64 import b16decode
import itertools
from functools import partial
from collections import defaultdict, OrderedDict
import numpy as np
from scipy import linalg
from Crypto.Cipher import AES
import pytest
np.set_printoptions(formatter={'int': hex})
skip = pytest.mark.skip
# # # Utilities # # #
hex_decode = partial(b16decode, casefold=True)
def base64_from_hex(hex_str):
"""Set 1 - Challenge 1"""
return base64_encode(hex_decode(hex_str))
def array_from_hex(hex_str):
return np.frombuffer(hex_decode(hex_str), dtype=np.uint8)
afh = array_from_hex
def hex_from_array(arr):
return ''.join(hex(v)[2:] for v in arr)
hfa = hex_from_array
def bytes_from_array(arr):
return arr.tobytes()
bfa = bytes_from_array
def array_from_bytes(s):
return np.frombuffer(s, dtype=np.uint8)
afb = array_from_bytes
def line_array_from_hex_file(path):
"""Returns a (potentially) ragged array of arrays."""
lines = []
with open(path) as fh:
for line in fh:
lines.append(array_from_hex(line.strip()))
return np.array(lines)
def array_from_base64(s):
data = base64_decode(s)
return np.frombuffer(data, np.uint8)
afb64 = array_from_base64
def hamming_distance(d0, d1):
return np.unpackbits(d0 ^ d1).sum()
# # # Tests for Utilities # # #
def test_base64_from_hex():
hex_data = b"49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d"
base64_result = b"SS<KEY>"
assert base64_from_hex(hex_data) == base64_result
def test_array_from_hex():
hex_data = b"4927abcd"
expected = np.array([0x49, 0x27, 0xab, 0xcd], dtype=np.uint8)
result = array_from_hex(hex_data)
assert np.all(result == expected)
def test_hex_from_array():
data = np.array([0x49, 0x27, 0xab, 0xcd], dtype=np.uint8)
expected = "4927abcd"
result = hex_from_array(data)
assert result == expected
def test_bytes_from_array():
data = np.array([104, 101, 108, 108, 111], dtype=np.uint8)
expected = b'hello'
assert bytes_from_array(data) == expected
def test_array_from_bytes():
data = b'hello'
expected = np.array([104, 101, 108, 108, 111], dtype=np.uint8)
assert np.all(array_from_bytes(data) == expected)
def test_hamming_distance():
s0 = b"this is a test"
s1 = b"wokka wokka!!!"
assert hamming_distance(afb(s0), afb(s1)) == 37
# # # Crypto # # #
letters = map(ord, 'abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ')
letter_probabilities = \
[0.0651738, 0.0124248, 0.0217339, 0.0349835, 0.1041442, 0.0197881,
0.0158610, 0.0492888, 0.0558094, 0.0009033, 0.0050529, 0.0331490,
0.0202124, 0.0564513, 0.0596302, 0.0137645, 0.0008606, 0.0497563,
0.0515760, 0.0729357, 0.0225134, 0.0082903, 0.0171272, 0.0013692,
0.0145984, 0.0007836,
0.1918182,
0.0651738, 0.0124248, 0.0217339, 0.0349835, 0.1041442, 0.0197881,
0.0158610, 0.0492888, 0.0558094, 0.0009033, 0.0050529, 0.0331490,
0.0202124, 0.0564513, 0.0596302, 0.0137645, 0.0008606, 0.0497563,
0.0515760, 0.0729357, 0.0225134, 0.0082903, 0.0171272, 0.0013692,
0.0145984, 0.0007836]
probability_from_char = defaultdict(float, zip(letters, letter_probabilities))
def _score_char(c):
return probability_from_char[c]
score_char = np.vectorize(_score_char)
def decrypt_single_byte_xor(plaintext, return_score=False):
"""Set 1 - Challenge 3
Discover the single-byte key and return plaintext.
If `return_score` is True, also return a 2-element array where element 0
is the message and element 1 is the score.
"""
data = plaintext.reshape(1, -1)
keys = np.arange(256, dtype=np.uint8).reshape(-1, 1)
messages = data ^ keys
scores = score_char(messages)
message_scores = scores.sum(axis=1)
best_message_index = message_scores.argmax()
best_message = messages[best_message_index]
best_message_score = message_scores[best_message_index]
if return_score:
return np.array([best_message, best_message_score])
else:
return best_message
def detect_single_byte_xor(ciphertext_lines):
"""Set 1 - Challenge 4
ciphertext_lines: ragged array returned from line_array_from_hex_file
"""
messages = np.array([decrypt_single_byte_xor(line, return_score=True)
for line in ciphertext_lines])
best_idx = messages[:, 1].argmax()
return messages[best_idx][0]
def encrypt_repeating_key_xor(data, key):
"""Set 1 - Challenge 5"""
key_arr = np.array(list(itertools.islice(itertools.cycle(key), len(data))))
return data ^ key_arr
def normalized_hamming(data, keysize):
"""Hamming distance divided by keysize"""
h0 = hamming_distance(data[0*keysize:3*keysize], data[3*keysize:6*keysize])
return h0 / keysize
def find_likely_keysizes(data):
"""Returns a sorted list of (keysize, score), sorted by score"""
keysizes = range(2, 41)
norm_distances = []
for keysize in keysizes:
norm_distances.append(normalized_hamming(data, keysize))
size_and_score = list(zip(keysizes, norm_distances))
return sorted(size_and_score, key=lambda ss: ss[1])
def _decrypt_repeating_key_xor(data):
keysizes = find_likely_keysizes(data)
for keysize, _ in keysizes:
pad_len, padded_data = pkcs7(data, keysize, return_len=True)
padded_data.shape = (-1, keysize)
decrypted = np.apply_along_axis(decrypt_single_byte_xor, axis=0,
arr=padded_data)
decrypted.shape = (-1,)
if pad_len > 0:
decrypted = decrypted[:-pad_len]
yield decrypted
def decrypt_repeating_key_xor(data):
"""Set 1 - Challenge 6"""
candidates = _decrypt_repeating_key_xor(data)
return next(candidates)
def decrypt_aes_ecb(ciphertext, key=afb(b'YELLOW SUBMARINE'), blocksize=16):
"""Set 1 - Challenge 7"""
padded_cipher = pkcs7(ciphertext, blocksize)
padded_key = pkcs7(key, blocksize)
decrypter = AES.new(padded_key, AES.MODE_ECB)
plaintext = afb(decrypter.decrypt(padded_cipher))
return plaintext
def detect_aes_ecb(data, blocksize=16):
"""Set 1 - Challenge 8
Returns index of AES ECB encoded row.
"""
row_scores = []
for i, row in enumerate(data):
blocks = row.view(dtype=np.dtype([('data', (np.uint8, blocksize))]))
counts = np.unique(blocks, return_counts=True)[1]
most_repetition = counts.max()
row_scores.append((i, most_repetition))
return max(row_scores, key=lambda index_count: index_count[1])
def pkcs7(data, blocksize=16, return_len=False):
"""Set 1 - Challenge 9
Pad an array to `blocksize` with a constant value: the number of bytes
needed to complete the last block.
`return_len`, if set to True, will also return the pad value used.
"""
pad_remainder = data.size % blocksize
pad_len = (blocksize - pad_remainder) % blocksize
padded_data = np.pad(data, (0, pad_len), mode='constant',
constant_values=pad_len)
if return_len:
return pad_len, padded_data
else:
return padded_data
def encrypt_aes_ecb(data, key, blocksize=16):
"""Set 2 - Challenge 10"""
data = pkcs7(data, blocksize)
key = pkcs7(key, blocksize)
encrypter = AES.new(key, AES.MODE_ECB)
return np.frombuffer(encrypter.encrypt(data), dtype=np.uint8)
def encrypt_aes_cbc(plaintext, key, iv, blocksize=16):
plain = pkcs7(plaintext, blocksize=blocksize)
plain.shape = (-1, blocksize)
cipher = np.empty_like(plain)
for i, _ in enumerate(cipher):
if i == 0:
cipher[i] = encrypt_aes_ecb(plain[i] ^ iv, key=key)
else:
cipher[i] = encrypt_aes_ecb(plain[i] ^ cipher[i-1], key=key)
cipher.shape = (-1,)
return cipher
def decrypt_aes_cbc_serial(ciphertext, key, iv, blocksize=16):
"""Set 2 - Challenge 10"""
cipher = pkcs7(ciphertext, blocksize=blocksize)
cipher.shape = (-1, blocksize)
plain = np.empty_like(cipher)
for i, _ in enumerate(cipher):
if i == 0:
plain[i] = decrypt_aes_ecb(cipher[i], key=key) ^ iv
else:
plain[i] = decrypt_aes_ecb(cipher[i], key=key) ^ cipher[i-1]
plain.shape = (-1,)
return strip_pkcs7(plain, blocksize=blocksize)
def decrypt_aes_cbc(ciphertext, key, iv, blocksize=16):
"""Set 2 - Challenge 10
Vectorized.
"""
# decrypt
cipher = pkcs7(ciphertext, blocksize=blocksize)
plain = afb(decrypt_aes_ecb(ciphertext, key=key, blocksize=blocksize))
# XOR plaintext blocks with previous ciphertext blocks
# (iv for 0th block)
plain = plain ^ np.hstack((iv, cipher[:-1]))[:plain.size]
return strip_pkcs7(plain, blocksize=blocksize)
def random_aes_key(blocksize=16):
"""Set 2 - Challenge 11"""
return afb(np.random.bytes(blocksize))
def encryption_oracle(plaintext, blocksize=16, force_mode=None):
"""Set 2 - Challenge 11
Encrypt data using a random key, with random padding, in ECB or CBC mode
(randomly).
For testing, you can force the mode to be 'ECB' or 'CBC', with
force_mode='ECB' or force_mode='CBC'
"""
left_pad, right_pad = | np.random.randint(5, 11, 2) | numpy.random.randint |
import pandas as pd
import numpy as np
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
from matplotlib import cm, colors
from astropy.modeling import models, fitting
# Reading in all data files at once
import glob
path_normal ='/projects/p30137/ageller/testing/EBLSST/add_m5/output_files'
allFiles_normal = glob.glob(path_normal + "/*.csv")
path_fast = '/projects/p30137/ageller/testing/EBLSST/add_m5/fast/old/output_files'
allFiles_fast = glob.glob(path_fast + "/*.csv")
path_obsDist = '/projects/p30137/ageller/testing/EBLSST/add_m5/fast/old/obsDist/output_files'
allFiles_obsDist = glob.glob(path_obsDist + "/*.csv")
N_totalnormal_array = []
N_totalobservablenormal_array = []
N_totalrecoverablenormal_array = []
N_totalnormal_array_03 = []
N_totalobservablenormal_array_03 = []
N_totalrecoverablenormal_array_03 = []
N_totalnormal_array_1 = []
N_totalobservablenormal_array_1 = []
N_totalrecoverablenormal_array_1 = []
N_totalnormal_array_10 = []
N_totalobservablenormal_array_10 = []
N_totalrecoverablenormal_array_10 = []
N_totalnormal_array_30 = []
N_totalobservablenormal_array_30 = []
N_totalrecoverablenormal_array_30 = []
N_totalnormal_array_100 = []
N_totalobservablenormal_array_100 = []
N_totalrecoverablenormal_array_100 = []
N_totalnormal_array_1000 = []
N_totalobservablenormal_array_1000 = []
N_totalrecoverablenormal_array_1000 = []
N_totalnormal22_array = []
N_totalobservablenormal22_array = []
N_totalrecoverablenormal22_array = []
N_totalnormal22_array_03 = []
N_totalobservablenormal22_array_03 = []
N_totalrecoverablenormal22_array_03 = []
N_totalnormal22_array_1 = []
N_totalobservablenormal22_array_1 = []
N_totalrecoverablenormal22_array_1 = []
N_totalnormal22_array_10 = []
N_totalobservablenormal22_array_10 = []
N_totalrecoverablenormal22_array_10 = []
N_totalnormal22_array_30 = []
N_totalobservablenormal22_array_30 = []
N_totalrecoverablenormal22_array_30 = []
N_totalnormal22_array_100 = []
N_totalobservablenormal22_array_100 = []
N_totalrecoverablenormal22_array_100 = []
N_totalnormal22_array_1000 = []
N_totalobservablenormal22_array_1000 = []
N_totalrecoverablenormal22_array_1000 = []
N_totalnormal195_array = []
N_totalobservablenormal195_array = []
N_totalrecoverablenormal195_array = []
N_totalnormal195_array_03 = []
N_totalobservablenormal195_array_03 = []
N_totalrecoverablenormal195_array_03 = []
N_totalnormal195_array_1 = []
N_totalobservablenormal195_array_1 = []
N_totalrecoverablenormal195_array_1 = []
N_totalnormal195_array_10 = []
N_totalobservablenormal195_array_10 = []
N_totalrecoverablenormal195_array_10 = []
N_totalnormal195_array_30 = []
N_totalobservablenormal195_array_30 = []
N_totalrecoverablenormal195_array_30 = []
N_totalnormal195_array_100 = []
N_totalobservablenormal195_array_100 = []
N_totalrecoverablenormal195_array_100 = []
N_totalnormal195_array_1000 = []
N_totalobservablenormal195_array_1000 = []
N_totalrecoverablenormal195_array_1000 = []
N_totalfast_array = []
N_totalobservablefast_array = []
N_totalrecoverablefast_array = []
N_totalfast_array_03 = []
N_totalobservablefast_array_03 = []
N_totalrecoverablefast_array_03 = []
N_totalfast_array_1 = []
N_totalobservablefast_array_1 = []
N_totalrecoverablefast_array_1 = []
N_totalfast_array_10 = []
N_totalobservablefast_array_10 = []
N_totalrecoverablefast_array_10 = []
N_totalfast_array_30 = []
N_totalobservablefast_array_30 = []
N_totalrecoverablefast_array_30 = []
N_totalfast_array_100 = []
N_totalobservablefast_array_100 = []
N_totalrecoverablefast_array_100 = []
N_totalfast_array_1000 = []
N_totalobservablefast_array_1000 = []
N_totalrecoverablefast_array_1000 = []
N_totalfast22_array = []
N_totalobservablefast22_array = []
N_totalrecoverablefast22_array = []
N_totalfast22_array_03 = []
N_totalobservablefast22_array_03 = []
N_totalrecoverablefast22_array_03 = []
N_totalfast22_array_1 = []
N_totalobservablefast22_array_1 = []
N_totalrecoverablefast22_array_1 = []
N_totalfast22_array_10 = []
N_totalobservablefast22_array_10 = []
N_totalrecoverablefast22_array_10 = []
N_totalfast22_array_30 = []
N_totalobservablefast22_array_30 = []
N_totalrecoverablefast22_array_30 = []
N_totalfast22_array_100 = []
N_totalobservablefast22_array_100 = []
N_totalrecoverablefast22_array_100 = []
N_totalfast22_array_1000 = []
N_totalobservablefast22_array_1000 = []
N_totalrecoverablefast22_array_1000 = []
N_totalfast195_array = []
N_totalobservablefast195_array = []
N_totalrecoverablefast195_array = []
N_totalfast195_array_03 = []
N_totalobservablefast195_array_03 = []
N_totalrecoverablefast195_array_03 = []
N_totalfast195_array_1 = []
N_totalobservablefast195_array_1 = []
N_totalrecoverablefast195_array_1 = []
N_totalfast195_array_10 = []
N_totalobservablefast195_array_10 = []
N_totalrecoverablefast195_array_10 = []
N_totalfast195_array_30 = []
N_totalobservablefast195_array_30 = []
N_totalrecoverablefast195_array_30 = []
N_totalfast195_array_100 = []
N_totalobservablefast195_array_100 = []
N_totalrecoverablefast195_array_100 = []
N_totalfast195_array_1000 = []
N_totalobservablefast195_array_1000 = []
N_totalrecoverablefast195_array_1000 = []
N_totalobsDist_array = []
N_totalobservableobsDist_array = []
N_totalrecoverableobsDist_array = []
N_totalobsDist_array_03 = []
N_totalobservableobsDist_array_03 = []
N_totalrecoverableobsDist_array_03 = []
N_totalobsDist_array_1 = []
N_totalobservableobsDist_array_1 = []
N_totalrecoverableobsDist_array_1 = []
N_totalobsDist_array_10 = []
N_totalobservableobsDist_array_10 = []
N_totalrecoverableobsDist_array_10 = []
N_totalobsDist_array_30 = []
N_totalobservableobsDist_array_30 = []
N_totalrecoverableobsDist_array_30 = []
N_totalobsDist_array_100 = []
N_totalobservableobsDist_array_100 = []
N_totalrecoverableobsDist_array_100 = []
N_totalobsDist_array_1000 = []
N_totalobservableobsDist_array_1000 = []
N_totalrecoverableobsDist_array_1000 = []
N_totalobsDist22_array = []
N_totalobservableobsDist22_array = []
N_totalrecoverableobsDist22_array = []
N_totalobsDist22_array_03 = []
N_totalobservableobsDist22_array_03 = []
N_totalrecoverableobsDist22_array_03 = []
N_totalobsDist22_array_1 = []
N_totalobservableobsDist22_array_1 = []
N_totalrecoverableobsDist22_array_1 = []
N_totalobsDist22_array_10 = []
N_totalobservableobsDist22_array_10 = []
N_totalrecoverableobsDist22_array_10 = []
N_totalobsDist22_array_30 = []
N_totalobservableobsDist22_array_30 = []
N_totalrecoverableobsDist22_array_30 = []
N_totalobsDist22_array_100 = []
N_totalobservableobsDist22_array_100 = []
N_totalrecoverableobsDist22_array_100 = []
N_totalobsDist22_array_1000 = []
N_totalobservableobsDist22_array_1000 = []
N_totalrecoverableobsDist22_array_1000 = []
N_totalobsDist195_array = []
N_totalobservableobsDist195_array = []
N_totalrecoverableobsDist195_array = []
N_totalobsDist195_array_03 = []
N_totalobservableobsDist195_array_03 = []
N_totalrecoverableobsDist195_array_03 = []
N_totalobsDist195_array_1 = []
N_totalobservableobsDist195_array_1 = []
N_totalrecoverableobsDist195_array_1 = []
N_totalobsDist195_array_10 = []
N_totalobservableobsDist195_array_10 = []
N_totalrecoverableobsDist195_array_10 = []
N_totalobsDist195_array_30 = []
N_totalobservableobsDist195_array_30 = []
N_totalrecoverableobsDist195_array_30 = []
N_totalobsDist195_array_100 = []
N_totalobservableobsDist195_array_100 = []
N_totalrecoverableobsDist195_array_100 = []
N_totalobsDist195_array_1000 = []
N_totalobservableobsDist195_array_1000 = []
N_totalrecoverableobsDist195_array_1000 = []
def fitRagfb():
x = [0.05, 0.1, 1, 8, 15] #estimates of midpoints in bins, and using this: https:/sites.uni.edu/morgans/astro/course/Notes/section2/spectralmasses.html
y = [0.20, 0.35, 0.50, 0.70, 0.75]
init = models.PowerLaw1D(amplitude=0.5, x_0=1, alpha=-1.)
fitter = fitting.LevMarLSQFitter()
fit = fitter(init, x, y)
return fit
fbFit= fitRagfb()
mbins = np.arange(0,10, 0.1, dtype='float')
cutP = 0.10 #condition on recoverability/tolerance
for filenormal_ in sorted(allFiles_normal):
filename = filenormal_[60:]
fileid = filename.strip('output_file.csv')
print ("I'm starting " + fileid)
datnormal = pd.read_csv(filenormal_, sep = ',', header=2)
PeriodIn = datnormal['p'] # input period -- 'p' in data file
##########################################################
datnormal1 = pd.read_csv(filenormal_, sep = ',', header=0, nrows=1)
N_tri = datnormal1["NstarsTRILEGAL"][0]
#print("N_tri = ", N_tri)
Nall = len(PeriodIn)
m1hAll0, m1b = np.histogram(datnormal["m1"], bins=mbins)
dm1 = np.diff(m1b)
m1val = m1b[:-1] + dm1/2.
fb = np.sum(m1hAll0/Nall*fbFit(m1val))
N_mult = N_tri*fb
##########################################################
if len(PeriodIn) == 0.:
continue
if N_tri == 0:
continue
else:
PeriodOut = datnormal['LSM_PERIOD'] #LSM_PERIOD in data file
appMagMean = datnormal['appMagMean'] #apparent magnitude, will use to make cuts for 24 (default), 22, and then Kepler's range (?? -- brighter than LSST can manage-- to 19) OR 19.5 (SNR = 10)
observable = datnormal.loc[PeriodOut != -999].index
observable_03 = datnormal.loc[(PeriodIn <= 0.3) & (PeriodOut != -999)].index
observable_1 = datnormal.loc[(PeriodIn <= 1) & (PeriodOut != -999)].index
observable_10 = datnormal.loc[(PeriodIn <= 10) & (PeriodOut != -999)].index
observable_30 = datnormal.loc[(PeriodIn <= 30) & (PeriodOut != -999)].index
observable_100 = datnormal.loc[(PeriodIn <= 100) & (PeriodOut != -999)].index
observable_1000 = datnormal.loc[(PeriodIn <= 1000) & (PeriodOut != -999)].index
observable_22 = datnormal.loc[(PeriodOut != -999) & (appMagMean <= 22.)].index
observable_03_22 = datnormal.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_1_22 = datnormal.loc[(PeriodIn <= 1) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_10_22 = datnormal.loc[(PeriodIn <= 10) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_30_22 = datnormal.loc[(PeriodIn <= 30) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_100_22 = datnormal.loc[(PeriodIn <= 100) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_1000_22 = datnormal.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_195 = datnormal.loc[(PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_03_195 = datnormal.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_1_195 = datnormal.loc[(PeriodIn <= 1) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_10_195 = datnormal.loc[(PeriodIn <= 10) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_30_195 = datnormal.loc[(PeriodIn <= 30) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_100_195 = datnormal.loc[(PeriodIn <= 100) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_1000_195 = datnormal.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
fullP = abs(PeriodOut - PeriodIn)/PeriodIn
halfP = abs(PeriodOut - 0.5*PeriodIn)/(0.5*PeriodIn)
twiceP = abs(PeriodOut - 2*PeriodIn)/(2*PeriodIn)
recoverable = datnormal.loc[(PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_03 = datnormal.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_1 = datnormal.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_10 = datnormal.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_30 = datnormal.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_100 = datnormal.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_1000 = datnormal.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_22 = datnormal.loc[(PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_03_22 = datnormal.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_1_22 = datnormal.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_10_22 = datnormal.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_30_22 = datnormal.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_100_22 = datnormal.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_1000_22 = datnormal.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_195 = datnormal.loc[(PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_03_195 = datnormal.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_1_195 = datnormal.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_10_195 = datnormal.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_30_195 = datnormal.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_100_195 = datnormal.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_1000_195 = datnormal.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
P03 = datnormal.loc[PeriodIn <= 0.3].index
P1 = datnormal.loc[PeriodIn <= 1].index
P10 = datnormal.loc[PeriodIn <= 10].index
P30 = datnormal.loc[PeriodIn <= 30].index
P100 = datnormal.loc[PeriodIn <= 100].index
P1000 = datnormal.loc[PeriodIn <= 1000].index
P_22 = datnormal.loc[appMagMean <= 22.].index
P03_22 = datnormal.loc[(PeriodIn <= 0.3) & (appMagMean <= 22.)].index
P1_22 = datnormal.loc[(PeriodIn <= 1) & (appMagMean <= 22.)].index
P10_22 = datnormal.loc[(PeriodIn <= 10) & (appMagMean <= 22.)].index
P30_22 = datnormal.loc[(PeriodIn <= 30) & (appMagMean <= 22.)].index
P100_22 = datnormal.loc[(PeriodIn <= 100) & (appMagMean <= 22.)].index
P1000_22 = datnormal.loc[(PeriodIn <= 1000) & (appMagMean <= 22.)].index
P_195 = datnormal.loc[appMagMean <= 19.5].index
P03_195 = datnormal.loc[(PeriodIn <= 0.3) & (appMagMean <= 19.5)].index
P1_195 = datnormal.loc[(PeriodIn <= 1) & (appMagMean <= 19.5)].index
P10_195 = datnormal.loc[(PeriodIn <= 10) & (appMagMean <= 19.5)].index
P30_195 = datnormal.loc[(PeriodIn <= 30) & (appMagMean <= 19.5)].index
P100_195 = datnormal.loc[(PeriodIn <= 100) & (appMagMean <= 19.5)].index
P1000_195 = datnormal.loc[(PeriodIn <= 1000) & (appMagMean <= 19.5)].index
N_all = (len(PeriodIn)/len(PeriodIn))*N_mult
N_all03 = (len(P03)/len(PeriodIn))*N_mult
N_all1 = (len(P1)/len(PeriodIn))*N_mult
N_all10 = (len(P10)/len(PeriodIn))*N_mult
N_all30 = (len(P30)/len(PeriodIn))*N_mult
N_all100 = (len(P100)/len(PeriodIn))*N_mult
N_all1000 = (len(P1000)/len(PeriodIn))*N_mult
N_all_22 = (len(P_22)/len(PeriodIn))*N_mult
N_all03_22 = (len(P03_22)/len(PeriodIn))*N_mult
N_all1_22 = (len(P1_22)/len(PeriodIn))*N_mult
N_all10_22 = (len(P10_22)/len(PeriodIn))*N_mult
N_all30_22 = (len(P30_22)/len(PeriodIn))*N_mult
N_all100_22 = (len(P100_22)/len(PeriodIn))*N_mult
N_all1000_22 = (len(P1000_22)/len(PeriodIn))*N_mult
N_all_195 = (len(P_195)/len(PeriodIn))*N_mult
N_all03_195 = (len(P03_195)/len(PeriodIn))*N_mult
N_all1_195 = (len(P1_195)/len(PeriodIn))*N_mult
N_all10_195 = (len(P10_195)/len(PeriodIn))*N_mult
N_all30_195 = (len(P30_195)/len(PeriodIn))*N_mult
N_all100_195 = (len(P100_195)/len(PeriodIn))*N_mult
N_all1000_195 = (len(P1000_195)/len(PeriodIn))*N_mult
N_obs = (len(observable)/len(PeriodIn))*N_mult
N_obs03 = (len(observable_03)/len(PeriodIn))*N_mult
N_obs1 = (len(observable_1)/len(PeriodIn))*N_mult
N_obs10 = (len(observable_10)/len(PeriodIn))*N_mult
N_obs30 = (len(observable_30)/len(PeriodIn))*N_mult
N_obs100 = (len(observable_100)/len(PeriodIn))*N_mult
N_obs1000 = (len(observable_1000)/len(PeriodIn))*N_mult
N_obs_22 = (len(observable_22)/len(PeriodIn))*N_mult
N_obs03_22 = (len(observable_03_22)/len(PeriodIn))*N_mult
N_obs1_22 = (len(observable_1_22)/len(PeriodIn))*N_mult
N_obs10_22 = (len(observable_10_22)/len(PeriodIn))*N_mult
N_obs30_22 = (len(observable_30_22)/len(PeriodIn))*N_mult
N_obs100_22 = (len(observable_100_22)/len(PeriodIn))*N_mult
N_obs1000_22 = (len(observable_1000_22)/len(PeriodIn))*N_mult
N_obs_195 = (len(observable_195)/len(PeriodIn))*N_mult
N_obs03_195 = (len(observable_03_195)/len(PeriodIn))*N_mult
N_obs1_195 = (len(observable_1_195)/len(PeriodIn))*N_mult
N_obs10_195 = (len(observable_10_195)/len(PeriodIn))*N_mult
N_obs30_195 = (len(observable_30_195)/len(PeriodIn))*N_mult
N_obs100_195 = (len(observable_100_195)/len(PeriodIn))*N_mult
N_obs1000_195 = (len(observable_1000_195)/len(PeriodIn))*N_mult
N_rec = (len(recoverable)/len(PeriodIn))*N_mult
N_rec03 = (len(recoverable_03)/len(PeriodIn))*N_mult
N_rec1 = (len(recoverable_1)/len(PeriodIn))*N_mult
N_rec10 = (len(recoverable_10)/len(PeriodIn))*N_mult
N_rec30 = (len(recoverable_30)/len(PeriodIn))*N_mult
N_rec100 = (len(recoverable_100)/len(PeriodIn))*N_mult
N_rec1000 = (len(recoverable_1000)/len(PeriodIn))*N_mult
N_rec_22 = (len(recoverable_22)/len(PeriodIn))*N_mult
N_rec03_22 = (len(recoverable_03_22)/len(PeriodIn))*N_mult
N_rec1_22 = (len(recoverable_1_22)/len(PeriodIn))*N_mult
N_rec10_22 = (len(recoverable_10_22)/len(PeriodIn))*N_mult
N_rec30_22 = (len(recoverable_30_22)/len(PeriodIn))*N_mult
N_rec100_22 = (len(recoverable_100_22)/len(PeriodIn))*N_mult
N_rec1000_22 = (len(recoverable_1000_22)/len(PeriodIn))*N_mult
N_rec_195 = (len(recoverable_195)/len(PeriodIn))*N_mult
N_rec03_195 = (len(recoverable_03_195)/len(PeriodIn))*N_mult
N_rec1_195 = (len(recoverable_1_195)/len(PeriodIn))*N_mult
N_rec10_195 = (len(recoverable_10_195)/len(PeriodIn))*N_mult
N_rec30_195 = (len(recoverable_30_195)/len(PeriodIn))*N_mult
N_rec100_195 = (len(recoverable_100_195)/len(PeriodIn))*N_mult
N_rec1000_195 = (len(recoverable_1000_195)/len(PeriodIn))*N_mult
N_totalnormal_array.append(float(N_all))
N_totalobservablenormal_array.append(float(N_obs))
N_totalrecoverablenormal_array.append(float(N_rec))
N_totalnormal_array_03.append(float(N_all03))
N_totalobservablenormal_array_03.append(float(N_obs03))
N_totalrecoverablenormal_array_03.append(float(N_rec03))
N_totalnormal_array_1.append(float(N_all1))
N_totalobservablenormal_array_1.append(float(N_obs1))
N_totalrecoverablenormal_array_1.append(float(N_rec1))
N_totalnormal_array_10.append(float(N_all10))
N_totalobservablenormal_array_10.append(float(N_obs10))
N_totalrecoverablenormal_array_10.append(float(N_rec10))
N_totalnormal_array_30.append(float(N_all30))
N_totalobservablenormal_array_30.append(float(N_obs30))
N_totalrecoverablenormal_array_30.append(float(N_rec30))
N_totalnormal_array_100.append(float(N_all100))
N_totalobservablenormal_array_100.append(float(N_obs100))
N_totalrecoverablenormal_array_100.append(float(N_rec100))
N_totalnormal_array_1000.append(float(N_all1000))
N_totalobservablenormal_array_1000.append(float(N_obs1000))
N_totalrecoverablenormal_array_1000.append(float(N_rec1000))
N_totalnormal22_array.append(float(N_all_22))
N_totalobservablenormal22_array.append(float(N_obs_22))
N_totalrecoverablenormal22_array.append(float(N_rec_22))
N_totalnormal22_array_03.append(float(N_all03_22))
N_totalobservablenormal22_array_03.append(float(N_obs03_22))
N_totalrecoverablenormal22_array_03.append(float(N_rec03_22))
N_totalnormal22_array_1.append(float(N_all1_22))
N_totalobservablenormal22_array_1.append(float(N_obs1_22))
N_totalrecoverablenormal22_array_1.append(float(N_rec1_22))
N_totalnormal22_array_10.append(float(N_all10_22))
N_totalobservablenormal22_array_10.append(float(N_obs10_22))
N_totalrecoverablenormal22_array_10.append(float(N_rec10_22))
N_totalnormal22_array_30.append(float(N_all30_22))
N_totalobservablenormal22_array_30.append(float(N_obs30_22))
N_totalrecoverablenormal22_array_30.append(float(N_rec30_22))
N_totalnormal22_array_100.append(float(N_all100_22))
N_totalobservablenormal22_array_100.append(float(N_obs100_22))
N_totalrecoverablenormal22_array_100.append(float(N_rec100_22))
N_totalnormal22_array_1000.append(float(N_all1000_22))
N_totalobservablenormal22_array_1000.append(float(N_obs1000_22))
N_totalrecoverablenormal22_array_1000.append(float(N_rec1000_22))
N_totalnormal195_array.append(float(N_all_195))
N_totalobservablenormal195_array.append(float(N_obs_195))
N_totalrecoverablenormal195_array.append(float(N_rec_195))
N_totalnormal195_array_03.append(float(N_all03_195))
N_totalobservablenormal195_array_03.append(float(N_obs03_195))
N_totalrecoverablenormal195_array_03.append(float(N_rec03_195))
N_totalnormal195_array_1.append(float(N_all1_195))
N_totalobservablenormal195_array_1.append(float(N_obs1_195))
N_totalrecoverablenormal195_array_1.append(float(N_rec1_195))
N_totalnormal195_array_10.append(float(N_all10_195))
N_totalobservablenormal195_array_10.append(float(N_obs10_195))
N_totalrecoverablenormal195_array_10.append(float(N_rec10_195))
N_totalnormal195_array_30.append(float(N_all30_195))
N_totalobservablenormal195_array_30.append(float(N_obs30_195))
N_totalrecoverablenormal195_array_30.append(float(N_rec30_195))
N_totalnormal195_array_100.append(float(N_all100_195))
N_totalobservablenormal195_array_100.append(float(N_obs100_195))
N_totalrecoverablenormal195_array_100.append(float(N_rec100_195))
N_totalnormal195_array_1000.append(float(N_all1000_195))
N_totalobservablenormal195_array_1000.append(float(N_obs1000_195))
N_totalrecoverablenormal195_array_1000.append(float(N_rec1000_195))
N_totalnormal = np.sum(N_totalnormal_array)
N_totalnormal_03 = np.sum(N_totalnormal_array_03)
N_totalnormal_1 = np.sum(N_totalnormal_array_1)
N_totalnormal_10 = np.sum(N_totalnormal_array_10)
N_totalnormal_30 = np.sum(N_totalnormal_array_30)
N_totalnormal_100 = np.sum(N_totalnormal_array_100)
N_totalnormal_1000 = np.sum(N_totalnormal_array_1000)
N_totalobservablenormal = np.sum(N_totalobservablenormal_array)
N_totalobservablenormal_03 = np.sum(N_totalobservablenormal_array_03)
N_totalobservablenormal_1 = np.sum(N_totalobservablenormal_array_1)
N_totalobservablenormal_10 = np.sum(N_totalobservablenormal_array_10)
N_totalobservablenormal_30 = np.sum(N_totalobservablenormal_array_30)
N_totalobservablenormal_100 = np.sum(N_totalobservablenormal_array_100)
N_totalobservablenormal_1000 = np.sum(N_totalobservablenormal_array_1000)
N_totalrecoverablenormal = np.sum(N_totalrecoverablenormal_array)
N_totalrecoverablenormal_03 = np.sum(N_totalrecoverablenormal_array_03)
N_totalrecoverablenormal_1 = np.sum(N_totalrecoverablenormal_array_1)
N_totalrecoverablenormal_10 = np.sum(N_totalrecoverablenormal_array_10)
N_totalrecoverablenormal_30 = np.sum(N_totalrecoverablenormal_array_30)
N_totalrecoverablenormal_100 = np.sum(N_totalrecoverablenormal_array_100)
N_totalrecoverablenormal_1000 = np.sum(N_totalrecoverablenormal_array_1000)
N_totalnormal22 = np.sum(N_totalnormal22_array)
N_totalnormal22_03 = np.sum(N_totalnormal22_array_03)
N_totalnormal22_1 = np.sum(N_totalnormal22_array_1)
N_totalnormal22_10 = np.sum(N_totalnormal22_array_10)
N_totalnormal22_30 = np.sum(N_totalnormal22_array_30)
N_totalnormal22_100 = np.sum(N_totalnormal22_array_100)
N_totalnormal22_1000 = np.sum(N_totalnormal22_array_1000)
N_totalobservablenormal22 = np.sum(N_totalobservablenormal22_array)
N_totalobservablenormal22_03 = np.sum(N_totalobservablenormal22_array_03)
N_totalobservablenormal22_1 = np.sum(N_totalobservablenormal22_array_1)
N_totalobservablenormal22_10 = np.sum(N_totalobservablenormal22_array_10)
N_totalobservablenormal22_30 = np.sum(N_totalobservablenormal22_array_30)
N_totalobservablenormal22_100 = np.sum(N_totalobservablenormal22_array_100)
N_totalobservablenormal22_1000 = np.sum(N_totalobservablenormal22_array_1000)
N_totalrecoverablenormal22 = np.sum(N_totalrecoverablenormal22_array)
N_totalrecoverablenormal22_03 = np.sum(N_totalrecoverablenormal22_array_03)
N_totalrecoverablenormal22_1 = np.sum(N_totalrecoverablenormal22_array_1)
N_totalrecoverablenormal22_10 = np.sum(N_totalrecoverablenormal22_array_10)
N_totalrecoverablenormal22_30 = np.sum(N_totalrecoverablenormal22_array_30)
N_totalrecoverablenormal22_100 = np.sum(N_totalrecoverablenormal22_array_100)
N_totalrecoverablenormal22_1000 = np.sum(N_totalrecoverablenormal22_array_1000)
N_totalnormal195 = np.sum(N_totalnormal195_array)
N_totalnormal195_03 = np.sum(N_totalnormal195_array_03)
N_totalnormal195_1 = np.sum(N_totalnormal195_array_1)
N_totalnormal195_10 = np.sum(N_totalnormal195_array_10)
N_totalnormal195_30 = np.sum(N_totalnormal195_array_30)
N_totalnormal195_100 = np.sum(N_totalnormal195_array_100)
N_totalnormal195_1000 = np.sum(N_totalnormal195_array_1000)
N_totalobservablenormal195 = np.sum(N_totalobservablenormal195_array)
N_totalobservablenormal195_03 = np.sum(N_totalobservablenormal195_array_03)
N_totalobservablenormal195_1 = np.sum(N_totalobservablenormal195_array_1)
N_totalobservablenormal195_10 = np.sum(N_totalobservablenormal195_array_10)
N_totalobservablenormal195_30 = np.sum(N_totalobservablenormal195_array_30)
N_totalobservablenormal195_100 = np.sum(N_totalobservablenormal195_array_100)
N_totalobservablenormal195_1000 = np.sum(N_totalobservablenormal195_array_1000)
N_totalrecoverablenormal195 = np.sum(N_totalrecoverablenormal195_array)
N_totalrecoverablenormal195_03 = np.sum(N_totalrecoverablenormal195_array_03)
N_totalrecoverablenormal195_1 = np.sum(N_totalrecoverablenormal195_array_1)
N_totalrecoverablenormal195_10 = np.sum(N_totalrecoverablenormal195_array_10)
N_totalrecoverablenormal195_30 = np.sum(N_totalrecoverablenormal195_array_30)
N_totalrecoverablenormal195_100 = np.sum(N_totalrecoverablenormal195_array_100)
N_totalrecoverablenormal195_1000 = np.sum(N_totalrecoverablenormal195_array_1000)
wholerecoverypercent_normal = (N_totalrecoverablenormal/N_totalobservablenormal)*100
wholerecoverypercent_normal_03 = (N_totalrecoverablenormal_03/N_totalobservablenormal_03)*100
wholerecoverypercent_normal_1 = (N_totalrecoverablenormal_1/N_totalobservablenormal_1)*100
wholerecoverypercent_normal_10 = (N_totalrecoverablenormal_10/N_totalobservablenormal_10)*100
wholerecoverypercent_normal_30 = (N_totalrecoverablenormal_30/N_totalobservablenormal_30)*100
wholerecoverypercent_normal_100 = (N_totalrecoverablenormal_100/N_totalobservablenormal_100)*100
wholerecoverypercent_normal_1000 = (N_totalrecoverablenormal_1000/N_totalobservablenormal_1000)*100
sigmanormal = ((N_totalrecoverablenormal**(1/2))/N_totalobservablenormal)*100
sigmanormal_03 = ((N_totalrecoverablenormal_03**(1/2))/N_totalobservablenormal_03)*100
sigmanormal_1 = ((N_totalrecoverablenormal_1**(1/2))/N_totalobservablenormal_1)*100
sigmanormal_10 = ((N_totalrecoverablenormal_10**(1/2))/N_totalobservablenormal_10)*100
sigmanormal_30 = ((N_totalrecoverablenormal_30**(1/2))/N_totalobservablenormal_30)*100
sigmanormal_100 = ((N_totalrecoverablenormal_100**(1/2))/N_totalobservablenormal_100)*100
sigmanormal_1000 = ((N_totalrecoverablenormal_1000**(1/2))/N_totalobservablenormal_1000)*100
overallrecoverypercent_normal = (N_totalrecoverablenormal/N_totalnormal)*100
overallrecoverypercent_normal_03 = (N_totalrecoverablenormal_03/N_totalnormal_03)*100
overallrecoverypercent_normal_1 = (N_totalrecoverablenormal_1/N_totalnormal_1)*100
overallrecoverypercent_normal_10 = (N_totalrecoverablenormal_10/N_totalnormal_10)*100
overallrecoverypercent_normal_30 = (N_totalrecoverablenormal_30/N_totalnormal_30)*100
overallrecoverypercent_normal_100 = (N_totalrecoverablenormal_100/N_totalnormal_100)*100
overallrecoverypercent_normal_1000 = (N_totalrecoverablenormal_1000/N_totalnormal_1000)*100
overallsigmanormal = ((N_totalrecoverablenormal**(1/2))/N_totalnormal)*100
overallsigmanormal_03 = ((N_totalrecoverablenormal_03**(1/2))/N_totalnormal_03)*100
overallsigmanormal_1 = ((N_totalrecoverablenormal_1**(1/2))/N_totalnormal_1)*100
overallsigmanormal_10 = ((N_totalrecoverablenormal_10**(1/2))/N_totalnormal_10)*100
overallsigmanormal_30 = ((N_totalrecoverablenormal_30**(1/2))/N_totalnormal_30)*100
overallsigmanormal_100 = ((N_totalrecoverablenormal_100**(1/2))/N_totalnormal_100)*100
overallsigmanormal_1000 = ((N_totalrecoverablenormal_1000**(1/2))/N_totalnormal_1000)*100
wholerecoverypercent_normal22 = (N_totalrecoverablenormal22/N_totalobservablenormal22)*100
wholerecoverypercent_normal22_03 = (N_totalrecoverablenormal22_03/N_totalobservablenormal22_03)*100
wholerecoverypercent_normal22_1 = (N_totalrecoverablenormal22_1/N_totalobservablenormal22_1)*100
wholerecoverypercent_normal22_10 = (N_totalrecoverablenormal22_10/N_totalobservablenormal22_10)*100
wholerecoverypercent_normal22_30 = (N_totalrecoverablenormal22_30/N_totalobservablenormal22_30)*100
wholerecoverypercent_normal22_100 = (N_totalrecoverablenormal22_100/N_totalobservablenormal22_100)*100
wholerecoverypercent_normal22_1000 = (N_totalrecoverablenormal22_1000/N_totalobservablenormal22_1000)*100
sigmanormal22 = ((N_totalrecoverablenormal22**(1/2))/N_totalobservablenormal22)*100
sigmanormal22_03 = ((N_totalrecoverablenormal22_03**(1/2))/N_totalobservablenormal22_03)*100
sigmanormal22_1 = ((N_totalrecoverablenormal22_1**(1/2))/N_totalobservablenormal22_1)*100
sigmanormal22_10 = ((N_totalrecoverablenormal22_10**(1/2))/N_totalobservablenormal22_10)*100
sigmanormal22_30 = ((N_totalrecoverablenormal22_30**(1/2))/N_totalobservablenormal22_30)*100
sigmanormal22_100 = ((N_totalrecoverablenormal22_100**(1/2))/N_totalobservablenormal22_100)*100
sigmanormal22_1000 = ((N_totalrecoverablenormal22_1000**(1/2))/N_totalobservablenormal22_1000)*100
overallrecoverypercent_normal22 = (N_totalrecoverablenormal22/N_totalnormal22)*100
overallrecoverypercent_normal22_03 = (N_totalrecoverablenormal22_03/N_totalnormal22_03)*100
overallrecoverypercent_normal22_1 = (N_totalrecoverablenormal22_1/N_totalnormal22_1)*100
overallrecoverypercent_normal22_10 = (N_totalrecoverablenormal22_10/N_totalnormal22_10)*100
overallrecoverypercent_normal22_30 = (N_totalrecoverablenormal22_30/N_totalnormal22_30)*100
overallrecoverypercent_normal22_100 = (N_totalrecoverablenormal22_100/N_totalnormal22_100)*100
overallrecoverypercent_normal22_1000 = (N_totalrecoverablenormal22_1000/N_totalnormal22_1000)*100
overallsigmanormal22 = ((N_totalrecoverablenormal22**(1/2))/N_totalnormal22)*100
overallsigmanormal22_03 = ((N_totalrecoverablenormal22_03**(1/2))/N_totalnormal22_03)*100
overallsigmanormal22_1 = ((N_totalrecoverablenormal22_1**(1/2))/N_totalnormal22_1)*100
overallsigmanormal22_10 = ((N_totalrecoverablenormal22_10**(1/2))/N_totalnormal22_10)*100
overallsigmanormal22_30 = ((N_totalrecoverablenormal22_30**(1/2))/N_totalnormal22_30)*100
overallsigmanormal22_100 = ((N_totalrecoverablenormal22_100**(1/2))/N_totalnormal22_100)*100
overallsigmanormal22_1000 = ((N_totalrecoverablenormal22_1000**(1/2))/N_totalnormal22_1000)*100
wholerecoverypercent_normal195 = (N_totalrecoverablenormal195/N_totalobservablenormal195)*100
wholerecoverypercent_normal195_03 = (N_totalrecoverablenormal195_03/N_totalobservablenormal195_03)*100
wholerecoverypercent_normal195_1 = (N_totalrecoverablenormal195_1/N_totalobservablenormal195_1)*100
wholerecoverypercent_normal195_10 = (N_totalrecoverablenormal195_10/N_totalobservablenormal195_10)*100
wholerecoverypercent_normal195_30 = (N_totalrecoverablenormal195_30/N_totalobservablenormal195_30)*100
wholerecoverypercent_normal195_100 = (N_totalrecoverablenormal195_100/N_totalobservablenormal195_100)*100
wholerecoverypercent_normal195_1000 = (N_totalrecoverablenormal195_1000/N_totalobservablenormal195_1000)*100
sigmanormal195 = ((N_totalrecoverablenormal195**(1/2))/N_totalobservablenormal195)*100
sigmanormal195_03 = ((N_totalrecoverablenormal195_03**(1/2))/N_totalobservablenormal195_03)*100
sigmanormal195_1 = ((N_totalrecoverablenormal195_1**(1/2))/N_totalobservablenormal195_1)*100
sigmanormal195_10 = ((N_totalrecoverablenormal195_10**(1/2))/N_totalobservablenormal195_10)*100
sigmanormal195_30 = ((N_totalrecoverablenormal195_30**(1/2))/N_totalobservablenormal195_30)*100
sigmanormal195_100 = ((N_totalrecoverablenormal195_100**(1/2))/N_totalobservablenormal195_100)*100
sigmanormal195_1000 = ((N_totalrecoverablenormal195_1000**(1/2))/N_totalobservablenormal195_1000)*100
overallrecoverypercent_normal195 = (N_totalrecoverablenormal195/N_totalnormal195)*100
overallrecoverypercent_normal195_03 = (N_totalrecoverablenormal195_03/N_totalnormal195_03)*100
overallrecoverypercent_normal195_1 = (N_totalrecoverablenormal195_1/N_totalnormal195_1)*100
overallrecoverypercent_normal195_10 = (N_totalrecoverablenormal195_10/N_totalnormal195_10)*100
overallrecoverypercent_normal195_30 = (N_totalrecoverablenormal195_30/N_totalnormal195_30)*100
overallrecoverypercent_normal195_100 = (N_totalrecoverablenormal195_100/N_totalnormal195_100)*100
overallrecoverypercent_normal195_1000 = (N_totalrecoverablenormal195_1000/N_totalnormal195_1000)*100
overallsigmanormal195 = ((N_totalrecoverablenormal195**(1/2))/N_totalnormal195)*100
overallsigmanormal195_03 = ((N_totalrecoverablenormal195_03**(1/2))/N_totalnormal195_03)*100
overallsigmanormal195_1 = ((N_totalrecoverablenormal195_1**(1/2))/N_totalnormal195_1)*100
overallsigmanormal195_10 = ((N_totalrecoverablenormal195_10**(1/2))/N_totalnormal195_10)*100
overallsigmanormal195_30 = ((N_totalrecoverablenormal195_30**(1/2))/N_totalnormal195_30)*100
overallsigmanormal195_100 = ((N_totalrecoverablenormal195_100**(1/2))/N_totalnormal195_100)*100
overallsigmanormal195_1000 = ((N_totalrecoverablenormal195_1000**(1/2))/N_totalnormal195_1000)*100\
print("N_totalnormal = ", N_totalnormal, "and in log = ", np.log10(N_totalnormal), "**** N_totalobservablenormal = ", N_totalobservablenormal, "and in log = ", np.log10(N_totalobservablenormal), "**** N_totalrecoverablenormal = ", N_totalrecoverablenormal, "and in log = ", np.log10(N_totalrecoverablenormal))
print("N_totalnormal_03 = ", N_totalnormal_03, "and in log = ", np.log10(N_totalnormal_03), "**** N_totalobservablenormal_03 = ", N_totalobservablenormal_03, "and in log = ", np.log10(N_totalobservablenormal_03), "**** N_totalrecoverablenormal_03 = ", N_totalrecoverablenormal_03, "and in log = ", np.log10(N_totalrecoverablenormal_03))
print("N_totalnormal_1 = ", N_totalnormal_1, "and in log = ", np.log10(N_totalnormal_1), "**** N_totalobservablenormal_1 = ", N_totalobservablenormal_1, "and in log = ", np.log10(N_totalobservablenormal_1), "**** N_totalrecoverablenormal_1 = ", N_totalrecoverablenormal_1, "and in log = ", np.log10(N_totalrecoverablenormal_1))
print("N_totalnormal_10 = ", N_totalnormal_10, "and in log = ", np.log10(N_totalnormal_10), "**** N_totalobservablenormal_10 = ", N_totalobservablenormal_10, "and in log = ", np.log10(N_totalobservablenormal_10), "**** N_totalrecoverablenormal_10 = ", N_totalrecoverablenormal_10, "and in log = ", np.log10(N_totalrecoverablenormal_10))
print("N_totalnormal_30 = ", N_totalnormal_30, "and in log = ", np.log10(N_totalnormal_30), "**** N_totalobservablenormal_30 = ", N_totalobservablenormal_30, "and in log = ", np.log10(N_totalobservablenormal_30), "**** N_totalrecoverablenormal_30 = ", N_totalrecoverablenormal_30, "and in log = ", np.log10(N_totalrecoverablenormal_30))
print("N_totalnormal_100 = ", N_totalnormal_100, "and in log = ", np.log10(N_totalnormal_100), "**** N_totalobservablenormal_100 = ", N_totalobservablenormal_100, "and in log = ", np.log10(N_totalobservablenormal_100), "**** N_totalrecoverablenormal_100 = ", N_totalrecoverablenormal_100, "and in log = ", np.log10(N_totalrecoverablenormal_100))
print("N_totalnormal_1000 = ", N_totalnormal_1000, "and in log = ", np.log10(N_totalnormal_1000), "**** N_totalobservablenormal_1000 = ", N_totalobservablenormal_1000, "and in log = ", np.log10(N_totalobservablenormal_1000), "**** N_totalrecoverablenormal_1000 = ", N_totalrecoverablenormal_1000, "and in log = ", np.log10(N_totalrecoverablenormal_1000))
print("********************************")
print("wholerecoverypercent_normal = $", wholerecoverypercent_normal, "/pm", sigmanormal, "$")
print("wholerecoverypercent_normal_03 = $", wholerecoverypercent_normal_03, "/pm", sigmanormal_03, "$")
print("wholerecoverypercent_normal_1 = $", wholerecoverypercent_normal_1, "/pm", sigmanormal_1, "$")
print("wholerecoverypercent_normal_10 = $", wholerecoverypercent_normal_10, "/pm", sigmanormal_10, "$")
print("wholerecoverypercent_normal_30 = $", wholerecoverypercent_normal_30, "/pm", sigmanormal_30, "$")
print("wholerecoverypercent_normal_100 = $", wholerecoverypercent_normal_100, "/pm", sigmanormal_100, "$")
print("wholerecoverypercent_normal_1000 = $", wholerecoverypercent_normal_1000, "/pm", sigmanormal_1000, "$")
print("********************************")
print("overallrecoverypercent_normal = $", overallrecoverypercent_normal, "/pm", overallsigmanormal)
print("overallrecoverypercent_normal_03 = $", overallrecoverypercent_normal_03, "/pm", overallsigmanormal_03)
print("overallrecoverypercent_normal_1 = $", overallrecoverypercent_normal_1, "/pm", overallsigmanormal_1)
print("overallrecoverypercent_normal_10 = $", overallrecoverypercent_normal_10, "/pm", overallsigmanormal_10)
print("overallrecoverypercent_normal_30 = $", overallrecoverypercent_normal_30, "/pm", overallsigmanormal_30)
print("overallrecoverypercent_normal_100 = $", overallrecoverypercent_normal_100, "/pm", overallsigmanormal_100)
print("overallrecoverypercent_normal_1000 = $", overallrecoverypercent_normal_1000, "/pm", overallsigmanormal_1000)
print("################################")
print("N_totalnormal22 = ", N_totalnormal22, "and in log = ", np.log10(N_totalnormal22), "**** N_totalobservablenormal22 = ", N_totalobservablenormal22, "and in log = ", np.log10(N_totalobservablenormal22), "**** N_totalrecoverablenormal22 = ", N_totalrecoverablenormal22, "and in log = ", np.log10(N_totalrecoverablenormal22))
print("N_totalnormal22_03 = ", N_totalnormal22_03, "and in log = ", np.log10(N_totalnormal22_03), "**** N_totalobservablenormal22_03 = ", N_totalobservablenormal22_03, "and in log = ", np.log10(N_totalobservablenormal22_03), "**** N_totalrecoverablenormal22_03 = ", N_totalrecoverablenormal22_03, "and in log = ", np.log10(N_totalrecoverablenormal22_03))
print("N_totalnormal22_1 = ", N_totalnormal22_1, "and in log = ", np.log10(N_totalnormal22_1), "**** N_totalobservablenormal22_1 = ", N_totalobservablenormal22_1, "and in log = ", np.log10(N_totalobservablenormal22_1), "**** N_totalrecoverablenormal22_1 = ", N_totalrecoverablenormal22_1, "and in log = ", np.log10(N_totalrecoverablenormal22_1))
print("N_totalnormal22_10 = ", N_totalnormal22_10, "and in log = ", np.log10(N_totalnormal22_10), "**** N_totalobservablenormal22_10 = ", N_totalobservablenormal22_10, "and in log = ", np.log10(N_totalobservablenormal22_10), "**** N_totalrecoverablenormal22_10 = ", N_totalrecoverablenormal22_10, "and in log = ", np.log10(N_totalrecoverablenormal22_10))
print("N_totalnormal22_30 = ", N_totalnormal22_30, "and in log = ", np.log10(N_totalnormal22_30), "**** N_totalobservablenormal22_30 = ", N_totalobservablenormal22_30, "and in log = ", np.log10(N_totalobservablenormal22_30), "**** N_totalrecoverablenormal22_30 = ", N_totalrecoverablenormal22_30, "and in log = ", np.log10(N_totalrecoverablenormal22_30))
print("N_totalnormal22_100 = ", N_totalnormal22_100, "and in log = ", np.log10(N_totalnormal22_100), "**** N_totalobservablenormal22_100 = ", N_totalobservablenormal22_100, "and in log = ", np.log10(N_totalobservablenormal22_100), "**** N_totalrecoverablenormal22_100 = ", N_totalrecoverablenormal22_100, "and in log = ", np.log10(N_totalrecoverablenormal22_100))
print("N_totalnormal22_1000 = ", N_totalnormal22_1000, "and in log = ", np.log10(N_totalnormal22_1000), "**** N_totalobservablenormal22_1000 = ", N_totalobservablenormal22_1000, "and in log = ", np.log10(N_totalobservablenormal22_1000), "**** N_totalrecoverablenormal22_1000 = ", N_totalrecoverablenormal22_1000, "and in log = ", np.log10(N_totalrecoverablenormal22_1000))
print("********************************")
print("wholerecoverypercent_normal22 = $", wholerecoverypercent_normal22, "/pm", sigmanormal22, "$")
print("wholerecoverypercent_normal22_03 = $", wholerecoverypercent_normal22_03, "/pm", sigmanormal22_03, "$")
print("wholerecoverypercent_normal22_1 = $", wholerecoverypercent_normal22_1, "/pm", sigmanormal22_1, "$")
print("wholerecoverypercent_normal22_10 = $", wholerecoverypercent_normal22_10, "/pm", sigmanormal22_10, "$")
print("wholerecoverypercent_normal22_30 = $", wholerecoverypercent_normal22_30, "/pm", sigmanormal22_30, "$")
print("wholerecoverypercent_normal22_100 = $", wholerecoverypercent_normal22_100, "/pm", sigmanormal22_100, "$")
print("wholerecoverypercent_normal22_1000 = $", wholerecoverypercent_normal22_1000, "/pm", sigmanormal22_1000, "$")
print("********************************")
print("overallrecoverypercent_normal22 = $", overallrecoverypercent_normal22, "/pm", overallsigmanormal22, "$")
print("overallrecoverypercent_normal22_03 = $", overallrecoverypercent_normal22_03, "/pm", overallsigmanormal22_03, "$")
print("overallrecoverypercent_normal22_1 = $", overallrecoverypercent_normal22_1, "/pm", overallsigmanormal22_1, "$")
print("overallrecoverypercent_normal22_10 = $", overallrecoverypercent_normal22_10, "/pm", overallsigmanormal22_10, "$")
print("overallrecoverypercent_normal22_30 = $", overallrecoverypercent_normal22_30, "/pm", overallsigmanormal22_30, "$")
print("overallrecoverypercent_normal22_100 = $", overallrecoverypercent_normal22_100, "/pm", overallsigmanormal22_100, "$")
print("overallrecoverypercent_normal22_1000 = $", overallrecoverypercent_normal22_1000, "/pm", overallsigmanormal22_1000, "$")
print("###############################")
print("N_totalnormal195 = ", N_totalnormal195, "and in log = ", np.log10(N_totalnormal195), "**** N_totalobservablenormal195 = ", N_totalobservablenormal195, "and in log = ", np.log10(N_totalobservablenormal195), "**** N_totalrecoverablenormal195 = ", N_totalrecoverablenormal195, "and in log = ", np.log10(N_totalrecoverablenormal195))
print("N_totalnormal195_03 = ", N_totalnormal195_03, "and in log = ", np.log10(N_totalnormal195_03), "**** N_totalobservablenormal195_03 = ", N_totalobservablenormal195_03, "and in log = ", np.log10(N_totalobservablenormal195_03), "**** N_totalrecoverablenormal195_03 = ", N_totalrecoverablenormal195_03, "and in log = ", np.log10(N_totalrecoverablenormal195_03))
print("N_totalnormal195_1 = ", N_totalnormal195_1, "and in log = ", np.log10(N_totalnormal195_1), "**** N_totalobservablenormal195_1 = ", N_totalobservablenormal195_1, "and in log = ", np.log10(N_totalobservablenormal195_1), "**** N_totalrecoverablenormal195_1 = ", N_totalrecoverablenormal195_1, "and in log = ", np.log10(N_totalrecoverablenormal195_1))
print("N_totalnormal195_10 = ", N_totalnormal195_10, "and in log = ", np.log10(N_totalnormal195_10), "**** N_totalobservablenormal195_10 = ", N_totalobservablenormal195_10, "and in log = ", np.log10(N_totalobservablenormal195_10), "**** N_totalrecoverablenormal195_10 = ", N_totalrecoverablenormal195_10, "and in log = ", np.log10(N_totalrecoverablenormal195_10))
print("N_totalnormal195_30 = ", N_totalnormal195_30, "and in log = ", np.log10(N_totalnormal195_30), "**** N_totalobservablenormal195_30 = ", N_totalobservablenormal195_30, "and in log = ", np.log10(N_totalobservablenormal195_30), "**** N_totalrecoverablenormal195_30 = ", N_totalrecoverablenormal195_30, "and in log = ", np.log10(N_totalrecoverablenormal195_30))
print("N_totalnormal195_100 = ", N_totalnormal195_100, "and in log = ", np.log10(N_totalnormal195_100), "**** N_totalobservablenormal195_100 = ", N_totalobservablenormal195_100, "and in log = ", np.log10(N_totalobservablenormal195_100), "**** N_totalrecoverablenormal195_100 = ", N_totalrecoverablenormal195_100, "and in log = ", np.log10(N_totalrecoverablenormal195_100))
print("N_totalnormal195_1000 = ", N_totalnormal195_1000, "and in log = ", np.log10(N_totalnormal195_1000), "**** N_totalobservablenormal195_1000 = ", N_totalobservablenormal195_1000, "and in log = ", np.log10(N_totalobservablenormal195_1000), "**** N_totalrecoverablenormal195_1000 = ", N_totalrecoverablenormal195_1000, "and in log = ", np.log10(N_totalrecoverablenormal195_1000))
print("********************************")
print("wholerecoverypercent_normal195 = $", wholerecoverypercent_normal195, "/pm", sigmanormal195, "$")
print("wholerecoverypercent_normal195_03 = $", wholerecoverypercent_normal195_03, "/pm", sigmanormal195_03, "$")
print("wholerecoverypercent_normal195_1 = $", wholerecoverypercent_normal195_1, "/pm", sigmanormal195_1, "$")
print("wholerecoverypercent_normal195_10 = $", wholerecoverypercent_normal195_10, "/pm", sigmanormal195_10, "$")
print("wholerecoverypercent_normal195_30 = $", wholerecoverypercent_normal195_30, "/pm", sigmanormal195_30, "$")
print("wholerecoverypercent_normal195_100 = $", wholerecoverypercent_normal195_100, "/pm", sigmanormal195_100, "$")
print("wholerecoverypercent_normal195_1000 = $", wholerecoverypercent_normal195_1000, "/pm", sigmanormal195_1000, "$")
print("********************************")
print("overallrecoverypercent_normal195 = $", overallrecoverypercent_normal195, "/pm", overallsigmanormal195, "$")
print("overallrecoverypercent_normal195_03 = $", overallrecoverypercent_normal195_03, "/pm", overallsigmanormal195_03, "$")
print("overallrecoverypercent_normal195_1 = $", overallrecoverypercent_normal195_1, "/pm", overallsigmanormal195_1, "$")
print("overallrecoverypercent_normal195_10 = $", overallrecoverypercent_normal195_10, "/pm", overallsigmanormal195_10, "$")
print("overallrecoverypercent_normal195_30 = $", overallrecoverypercent_normal195_30, "/pm", overallsigmanormal195_30, "$")
print("overallrecoverypercent_normal195_100 = $", overallrecoverypercent_normal195_100, "/pm", overallsigmanormal195_100, "$")
print("overallrecoverypercent_normal195_1000 = $", overallrecoverypercent_normal195_1000, "/pm", overallsigmanormal195_1000, "$")
print("#############################")
print("binarypercent_22 = $", (N_totalnormal22/N_totalnormal)*100, "/pm", ((N_totalnormal22**(1/2))/N_totalnormal)*100, "$")
print("binarypercent_195 = $", (N_totalnormal195/N_totalnormal)*100, "/pm", ((N_totalnormal195**(1/2))/N_totalnormal)*100, "$")
print("binarypercent_03 = $", (N_totalnormal_03/N_totalnormal)*100, "/pm", ((N_totalnormal_03**(1/2))/N_totalnormal)*100, "$")
print("binarypercent_1 = $", (N_totalnormal_1/N_totalnormal)*100, "/pm", ((N_totalnormal_1**(1/2))/N_totalnormal)*100, "$")
print("binarypercent_10 = $", (N_totalnormal_10/N_totalnormal)*100, "/pm", ((N_totalnormal_10**(1/2))/N_totalnormal)*100, "$")
print("binarypercent_30 = $", (N_totalnormal_30/N_totalnormal)*100, "/pm", ((N_totalnormal_30**(1/2))/N_totalnormal)*100, "$")
print("binarypercent_100 = $", (N_totalnormal_100/N_totalnormal)*100, "/pm", ((N_totalnormal_100**(1/2))/N_totalnormal)*100, "$")
print("binarypercent_1000 = $", (N_totalnormal_1000/N_totalnormal)*100, "/pm", ((N_totalnormal_1000**(1/2))/N_totalnormal)*100, "$")
print("observablepercent_03 = $", (N_totalobservablenormal_03/N_totalnormal_03)*100, "/pm", ((N_totalobservablenormal_03**(1/2))/N_totalnormal_03)*100, "$")
print("observablepercent_1 = $", (N_totalobservablenormal_1/N_totalnormal_1)*100, "/pm", ((N_totalobservablenormal_1**(1/2))/N_totalnormal_1)*100, "$")
print("observablepercent_10 = $", (N_totalobservablenormal_10/N_totalnormal_10)*100, "/pm", ((N_totalobservablenormal_10**(1/2))/N_totalnormal_10)*100, "$")
print("observablepercent_30 = $", (N_totalobservablenormal_30/N_totalnormal_30)*100, "/pm", ((N_totalobservablenormal_30**(1/2))/N_totalnormal_30)*100, "$")
print("observablepercent_100 = $", (N_totalobservablenormal_100/N_totalnormal_100)*100, "/pm", ((N_totalobservablenormal_100**(1/2))/N_totalnormal_100)*100, "$")
print("observablepercent_1000 = $", (N_totalobservablenormal_1000/N_totalnormal_1000)*100, "/pm", ((N_totalobservablenormal_1000**(1/2))/N_totalnormal_1000)*100, "$")
print("observablepercent = $", (N_totalobservablenormal/N_totalnormal)*100, "/pm", ((N_totalobservablenormal**(1/2))/N_totalnormal)*100, "$")
print("observablepercent22 = $", (N_totalobservablenormal22/N_totalnormal22)*100, "/pm", ((N_totalobservablenormal22**(1/2))/N_totalnormal22)*100, "$")
print("observablepercent195 = $", (N_totalobservablenormal195/N_totalnormal195)*100, "/pm", ((N_totalobservablenormal195**(1/2))/N_totalnormal195)*100, "$")
for filefast_ in sorted(allFiles_fast):
filename = filefast_[69:] #when file path no longer has /old in it, will be filefast_[65:]
fileid = filename.strip('output_file.csv')
print ("I'm starting " + fileid)
datfast = pd.read_csv(filefast_, sep = ',', header=2)
PeriodIn = datfast['p'] # input period -- 'p' in data file
##########################################################
datfast1 = pd.read_csv(filefast_, sep = ',', header=0, nrows=1)
N_tri = datfast1["NstarsTRILEGAL"][0]
Nall = len(PeriodIn)
m1hAll0, m1b = np.histogram(datfast["m1"], bins=mbins)
dm1 = np.diff(m1b)
m1val = m1b[:-1] + dm1/2.
fb = np.sum(m1hAll0/Nall*fbFit(m1val))
N_mult = N_tri*fb
##########################################################
if len(PeriodIn) == 0.:
continue
if N_tri == 0:
continue
else:
PeriodOut = datfast['LSM_PERIOD'] #LSM_PERIOD in data file
appMagMean = datfast['appMagMean'] #apparent magnitude, will use to make cuts for 24 (default), 22, and then Kepler's range (?? -- brighter than LSST can manage-- to 19) OR 19.5 (SNR = 10)
observable = datfast.loc[PeriodOut != -999].index
observable_03 = datfast.loc[(PeriodIn <= 0.3) & (PeriodOut != -999)].index
observable_1 = datfast.loc[(PeriodIn <= 1) & (PeriodOut != -999)].index
observable_10 = datfast.loc[(PeriodIn <= 10) & (PeriodOut != -999)].index
observable_30 = datfast.loc[(PeriodIn <= 30) & (PeriodOut != -999)].index
observable_100 = datfast.loc[(PeriodIn <= 100) & (PeriodOut != -999)].index
observable_1000 = datfast.loc[(PeriodIn <= 1000) & (PeriodOut != -999)].index
observable_22 = datfast.loc[(PeriodOut != -999) & (appMagMean <= 22.)].index
observable_03_22 = datfast.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_1_22 = datfast.loc[(PeriodIn <= 1) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_10_22 = datfast.loc[(PeriodIn <= 10) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_30_22 = datfast.loc[(PeriodIn <= 30) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_100_22 = datfast.loc[(PeriodIn <= 100) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_1000_22 = datfast.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_195 = datfast.loc[(PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_03_195 = datfast.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_1_195 = datfast.loc[(PeriodIn <= 1) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_10_195 = datfast.loc[(PeriodIn <= 10) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_30_195 = datfast.loc[(PeriodIn <= 30) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_100_195 = datfast.loc[(PeriodIn <= 100) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_1000_195 = datfast.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
fullP = abs(PeriodOut - PeriodIn)/PeriodIn
halfP = abs(PeriodOut - 0.5*PeriodIn)/(0.5*PeriodIn)
twiceP = abs(PeriodOut - 2*PeriodIn)/(2*PeriodIn)
recoverable = datfast.loc[(PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_03 = datfast.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_1 = datfast.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_10 = datfast.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_30 = datfast.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_100 = datfast.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_1000 = datfast.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_22 = datfast.loc[(PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_03_22 = datfast.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_1_22 = datfast.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_10_22 = datfast.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_30_22 = datfast.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_100_22 = datfast.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_1000_22 = datfast.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_195 = datfast.loc[(PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_03_195 = datfast.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_1_195 = datfast.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_10_195 = datfast.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_30_195 = datfast.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_100_195 = datfast.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_1000_195 = datfast.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
P03 = datfast.loc[PeriodIn <= 0.3].index
P1 = datfast.loc[PeriodIn <= 1].index
P10 = datfast.loc[PeriodIn <= 10].index
P30 = datfast.loc[PeriodIn <= 30].index
P100 = datfast.loc[PeriodIn <= 100].index
P1000 = datfast.loc[PeriodIn <= 1000].index
P_22 = datfast.loc[appMagMean <= 22.].index
P03_22 = datfast.loc[(PeriodIn <= 0.3) & (appMagMean <= 22.)].index
P1_22 = datfast.loc[(PeriodIn <= 1) & (appMagMean <= 22.)].index
P10_22 = datfast.loc[(PeriodIn <= 10) & (appMagMean <= 22.)].index
P30_22 = datfast.loc[(PeriodIn <= 30) & (appMagMean <= 22.)].index
P100_22 = datfast.loc[(PeriodIn <= 100) & (appMagMean <= 22.)].index
P1000_22 = datfast.loc[(PeriodIn <= 1000) & (appMagMean <= 22.)].index
P_195 = datfast.loc[appMagMean <= 19.5].index
P03_195 = datfast.loc[(PeriodIn <= 0.3) & (appMagMean <= 19.5)].index
P1_195 = datfast.loc[(PeriodIn <= 1) & (appMagMean <= 19.5)].index
P10_195 = datfast.loc[(PeriodIn <= 10) & (appMagMean <= 19.5)].index
P30_195 = datfast.loc[(PeriodIn <= 30) & (appMagMean <= 19.5)].index
P100_195 = datfast.loc[(PeriodIn <= 100) & (appMagMean <= 19.5)].index
P1000_195 = datfast.loc[(PeriodIn <= 1000) & (appMagMean <= 19.5)].index
N_all = (len(PeriodIn)/len(PeriodIn))*N_mult
N_all03 = (len(P03)/len(PeriodIn))*N_mult
N_all1 = (len(P1)/len(PeriodIn))*N_mult
N_all10 = (len(P10)/len(PeriodIn))*N_mult
N_all30 = (len(P30)/len(PeriodIn))*N_mult
N_all100 = (len(P100)/len(PeriodIn))*N_mult
N_all1000 = (len(P1000)/len(PeriodIn))*N_mult
N_all_22 = (len(P_22)/len(PeriodIn))*N_mult
N_all03_22 = (len(P03_22)/len(PeriodIn))*N_mult
N_all1_22 = (len(P1_22)/len(PeriodIn))*N_mult
N_all10_22 = (len(P10_22)/len(PeriodIn))*N_mult
N_all30_22 = (len(P30_22)/len(PeriodIn))*N_mult
N_all100_22 = (len(P100_22)/len(PeriodIn))*N_mult
N_all1000_22 = (len(P1000_22)/len(PeriodIn))*N_mult
N_all_195 = (len(P_195)/len(PeriodIn))*N_mult
N_all03_195 = (len(P03_195)/len(PeriodIn))*N_mult
N_all1_195 = (len(P1_195)/len(PeriodIn))*N_mult
N_all10_195 = (len(P10_195)/len(PeriodIn))*N_mult
N_all30_195 = (len(P30_195)/len(PeriodIn))*N_mult
N_all100_195 = (len(P100_195)/len(PeriodIn))*N_mult
N_all1000_195 = (len(P1000_195)/len(PeriodIn))*N_mult
N_obs = (len(observable)/len(PeriodIn))*N_mult
N_obs03 = (len(observable_03)/len(PeriodIn))*N_mult
N_obs1 = (len(observable_1)/len(PeriodIn))*N_mult
N_obs10 = (len(observable_10)/len(PeriodIn))*N_mult
N_obs30 = (len(observable_30)/len(PeriodIn))*N_mult
N_obs100 = (len(observable_100)/len(PeriodIn))*N_mult
N_obs1000 = (len(observable_1000)/len(PeriodIn))*N_mult
N_obs_22 = (len(observable_22)/len(PeriodIn))*N_mult
N_obs03_22 = (len(observable_03_22)/len(PeriodIn))*N_mult
N_obs1_22 = (len(observable_1_22)/len(PeriodIn))*N_mult
N_obs10_22 = (len(observable_10_22)/len(PeriodIn))*N_mult
N_obs30_22 = (len(observable_30_22)/len(PeriodIn))*N_mult
N_obs100_22 = (len(observable_100_22)/len(PeriodIn))*N_mult
N_obs1000_22 = (len(observable_1000_22)/len(PeriodIn))*N_mult
N_obs_195 = (len(observable_195)/len(PeriodIn))*N_mult
N_obs03_195 = (len(observable_03_195)/len(PeriodIn))*N_mult
N_obs1_195 = (len(observable_1_195)/len(PeriodIn))*N_mult
N_obs10_195 = (len(observable_10_195)/len(PeriodIn))*N_mult
N_obs30_195 = (len(observable_30_195)/len(PeriodIn))*N_mult
N_obs100_195 = (len(observable_100_195)/len(PeriodIn))*N_mult
N_obs1000_195 = (len(observable_1000_195)/len(PeriodIn))*N_mult
N_rec = (len(recoverable)/len(PeriodIn))*N_mult
N_rec03 = (len(recoverable_03)/len(PeriodIn))*N_mult
N_rec1 = (len(recoverable_1)/len(PeriodIn))*N_mult
N_rec10 = (len(recoverable_10)/len(PeriodIn))*N_mult
N_rec30 = (len(recoverable_30)/len(PeriodIn))*N_mult
N_rec100 = (len(recoverable_100)/len(PeriodIn))*N_mult
N_rec1000 = (len(recoverable_1000)/len(PeriodIn))*N_mult
N_rec_22 = (len(recoverable_22)/len(PeriodIn))*N_mult
N_rec03_22 = (len(recoverable_03_22)/len(PeriodIn))*N_mult
N_rec1_22 = (len(recoverable_1_22)/len(PeriodIn))*N_mult
N_rec10_22 = (len(recoverable_10_22)/len(PeriodIn))*N_mult
N_rec30_22 = (len(recoverable_30_22)/len(PeriodIn))*N_mult
N_rec100_22 = (len(recoverable_100_22)/len(PeriodIn))*N_mult
N_rec1000_22 = (len(recoverable_1000_22)/len(PeriodIn))*N_mult
N_rec_195 = (len(recoverable_195)/len(PeriodIn))*N_mult
N_rec03_195 = (len(recoverable_03_195)/len(PeriodIn))*N_mult
N_rec1_195 = (len(recoverable_1_195)/len(PeriodIn))*N_mult
N_rec10_195 = (len(recoverable_10_195)/len(PeriodIn))*N_mult
N_rec30_195 = (len(recoverable_30_195)/len(PeriodIn))*N_mult
N_rec100_195 = (len(recoverable_100_195)/len(PeriodIn))*N_mult
N_rec1000_195 = (len(recoverable_1000_195)/len(PeriodIn))*N_mult
N_totalfast_array.append(float(N_all))
N_totalobservablefast_array.append(float(N_obs))
N_totalrecoverablefast_array.append(float(N_rec))
N_totalfast_array_03.append(float(N_all03))
N_totalobservablefast_array_03.append(float(N_obs03))
N_totalrecoverablefast_array_03.append(float(N_rec03))
N_totalfast_array_1.append(float(N_all1))
N_totalobservablefast_array_1.append(float(N_obs1))
N_totalrecoverablefast_array_1.append(float(N_rec1))
N_totalfast_array_10.append(float(N_all10))
N_totalobservablefast_array_10.append(float(N_obs10))
N_totalrecoverablefast_array_10.append(float(N_rec10))
N_totalfast_array_30.append(float(N_all30))
N_totalobservablefast_array_30.append(float(N_obs30))
N_totalrecoverablefast_array_30.append(float(N_rec30))
N_totalfast_array_100.append(float(N_all100))
N_totalobservablefast_array_100.append(float(N_obs100))
N_totalrecoverablefast_array_100.append(float(N_rec100))
N_totalfast_array_1000.append(float(N_all1000))
N_totalobservablefast_array_1000.append(float(N_obs1000))
N_totalrecoverablefast_array_1000.append(float(N_rec1000))
N_totalfast22_array.append(float(N_all_22))
N_totalobservablefast22_array.append(float(N_obs_22))
N_totalrecoverablefast22_array.append(float(N_rec_22))
N_totalfast22_array_03.append(float(N_all03_22))
N_totalobservablefast22_array_03.append(float(N_obs03_22))
N_totalrecoverablefast22_array_03.append(float(N_rec03_22))
N_totalfast22_array_1.append(float(N_all1_22))
N_totalobservablefast22_array_1.append(float(N_obs1_22))
N_totalrecoverablefast22_array_1.append(float(N_rec1_22))
N_totalfast22_array_10.append(float(N_all10_22))
N_totalobservablefast22_array_10.append(float(N_obs10_22))
N_totalrecoverablefast22_array_10.append(float(N_rec10_22))
N_totalfast22_array_30.append(float(N_all30_22))
N_totalobservablefast22_array_30.append(float(N_obs30_22))
N_totalrecoverablefast22_array_30.append(float(N_rec30_22))
N_totalfast22_array_100.append(float(N_all100_22))
N_totalobservablefast22_array_100.append(float(N_obs100_22))
N_totalrecoverablefast22_array_100.append(float(N_rec100_22))
N_totalfast22_array_1000.append(float(N_all1000_22))
N_totalobservablefast22_array_1000.append(float(N_obs1000_22))
N_totalrecoverablefast22_array_1000.append(float(N_rec1000_22))
N_totalfast195_array.append(float(N_all_195))
N_totalobservablefast195_array.append(float(N_obs_195))
N_totalrecoverablefast195_array.append(float(N_rec_195))
N_totalfast195_array_03.append(float(N_all03_195))
N_totalobservablefast195_array_03.append(float(N_obs03_195))
N_totalrecoverablefast195_array_03.append(float(N_rec03_195))
N_totalfast195_array_1.append(float(N_all1_195))
N_totalobservablefast195_array_1.append(float(N_obs1_195))
N_totalrecoverablefast195_array_1.append(float(N_rec1_195))
N_totalfast195_array_10.append(float(N_all10_195))
N_totalobservablefast195_array_10.append(float(N_obs10_195))
N_totalrecoverablefast195_array_10.append(float(N_rec10_195))
N_totalfast195_array_30.append(float(N_all30_195))
N_totalobservablefast195_array_30.append(float(N_obs30_195))
N_totalrecoverablefast195_array_30.append(float(N_rec30_195))
N_totalfast195_array_100.append(float(N_all100_195))
N_totalobservablefast195_array_100.append(float(N_obs100_195))
N_totalrecoverablefast195_array_100.append(float(N_rec100_195))
N_totalfast195_array_1000.append(float(N_all1000_195))
N_totalobservablefast195_array_1000.append(float(N_obs1000_195))
N_totalrecoverablefast195_array_1000.append(float(N_rec1000_195))
N_totalfast = np.sum(N_totalfast_array)
N_totalfast_03 = np.sum(N_totalfast_array_03)
N_totalfast_1 = np.sum(N_totalfast_array_1)
N_totalfast_10 = np.sum(N_totalfast_array_10)
N_totalfast_30 = np.sum(N_totalfast_array_30)
N_totalfast_100 = np.sum(N_totalfast_array_100)
N_totalfast_1000 = np.sum(N_totalfast_array_1000)
N_totalobservablefast = np.sum(N_totalobservablefast_array)
N_totalobservablefast_03 = np.sum(N_totalobservablefast_array_03)
N_totalobservablefast_1 = np.sum(N_totalobservablefast_array_1)
N_totalobservablefast_10 = np.sum(N_totalobservablefast_array_10)
N_totalobservablefast_30 = np.sum(N_totalobservablefast_array_30)
N_totalobservablefast_100 = np.sum(N_totalobservablefast_array_100)
N_totalobservablefast_1000 = np.sum(N_totalobservablefast_array_1000)
N_totalrecoverablefast = np.sum(N_totalrecoverablefast_array)
N_totalrecoverablefast_03 = np.sum(N_totalrecoverablefast_array_03)
N_totalrecoverablefast_1 = np.sum(N_totalrecoverablefast_array_1)
N_totalrecoverablefast_10 = np.sum(N_totalrecoverablefast_array_10)
N_totalrecoverablefast_30 = np.sum(N_totalrecoverablefast_array_30)
N_totalrecoverablefast_100 = np.sum(N_totalrecoverablefast_array_100)
N_totalrecoverablefast_1000 = np.sum(N_totalrecoverablefast_array_1000)
N_totalfast22 = np.sum(N_totalfast22_array)
N_totalfast22_03 = np.sum(N_totalfast22_array_03)
N_totalfast22_1 = np.sum(N_totalfast22_array_1)
N_totalfast22_10 = np.sum(N_totalfast22_array_10)
N_totalfast22_30 = np.sum(N_totalfast22_array_30)
N_totalfast22_100 = np.sum(N_totalfast22_array_100)
N_totalfast22_1000 = np.sum(N_totalfast22_array_1000)
N_totalobservablefast22 = np.sum(N_totalobservablefast22_array)
N_totalobservablefast22_03 = np.sum(N_totalobservablefast22_array_03)
N_totalobservablefast22_1 = np.sum(N_totalobservablefast22_array_1)
N_totalobservablefast22_10 = np.sum(N_totalobservablefast22_array_10)
N_totalobservablefast22_30 = np.sum(N_totalobservablefast22_array_30)
N_totalobservablefast22_100 = np.sum(N_totalobservablefast22_array_100)
N_totalobservablefast22_1000 = np.sum(N_totalobservablefast22_array_1000)
N_totalrecoverablefast22 = np.sum(N_totalrecoverablefast22_array)
N_totalrecoverablefast22_03 = np.sum(N_totalrecoverablefast22_array_03)
N_totalrecoverablefast22_1 = np.sum(N_totalrecoverablefast22_array_1)
N_totalrecoverablefast22_10 = np.sum(N_totalrecoverablefast22_array_10)
N_totalrecoverablefast22_30 = np.sum(N_totalrecoverablefast22_array_30)
N_totalrecoverablefast22_100 = np.sum(N_totalrecoverablefast22_array_100)
N_totalrecoverablefast22_1000 = np.sum(N_totalrecoverablefast22_array_1000)
N_totalfast195 = np.sum(N_totalfast195_array)
N_totalfast195_03 = np.sum(N_totalfast195_array_03)
N_totalfast195_1 = np.sum(N_totalfast195_array_1)
N_totalfast195_10 = np.sum(N_totalfast195_array_10)
N_totalfast195_30 = np.sum(N_totalfast195_array_30)
N_totalfast195_100 = np.sum(N_totalfast195_array_100)
N_totalfast195_1000 = np.sum(N_totalfast195_array_1000)
N_totalobservablefast195 = np.sum(N_totalobservablefast195_array)
N_totalobservablefast195_03 = np.sum(N_totalobservablefast195_array_03)
N_totalobservablefast195_1 = np.sum(N_totalobservablefast195_array_1)
N_totalobservablefast195_10 = np.sum(N_totalobservablefast195_array_10)
N_totalobservablefast195_30 = np.sum(N_totalobservablefast195_array_30)
N_totalobservablefast195_100 = np.sum(N_totalobservablefast195_array_100)
N_totalobservablefast195_1000 = np.sum(N_totalobservablefast195_array_1000)
N_totalrecoverablefast195 = np.sum(N_totalrecoverablefast195_array)
N_totalrecoverablefast195_03 = np.sum(N_totalrecoverablefast195_array_03)
N_totalrecoverablefast195_1 = np.sum(N_totalrecoverablefast195_array_1)
N_totalrecoverablefast195_10 = np.sum(N_totalrecoverablefast195_array_10)
N_totalrecoverablefast195_30 = np.sum(N_totalrecoverablefast195_array_30)
N_totalrecoverablefast195_100 = np.sum(N_totalrecoverablefast195_array_100)
N_totalrecoverablefast195_1000 = np.sum(N_totalrecoverablefast195_array_1000)
wholerecoverypercent_fast = (N_totalrecoverablefast/N_totalobservablefast)*100
wholerecoverypercent_fast_03 = (N_totalrecoverablefast_03/N_totalobservablefast_03)*100
wholerecoverypercent_fast_1 = (N_totalrecoverablefast_1/N_totalobservablefast_1)*100
wholerecoverypercent_fast_10 = (N_totalrecoverablefast_10/N_totalobservablefast_10)*100
wholerecoverypercent_fast_30 = (N_totalrecoverablefast_30/N_totalobservablefast_30)*100
wholerecoverypercent_fast_100 = (N_totalrecoverablefast_100/N_totalobservablefast_100)*100
wholerecoverypercent_fast_1000 = (N_totalrecoverablefast_1000/N_totalobservablefast_1000)*100
sigmafast = ((N_totalrecoverablefast**(1/2))/N_totalobservablefast)*100
sigmafast_03 = ((N_totalrecoverablefast_03**(1/2))/N_totalobservablefast_03)*100
sigmafast_1 = ((N_totalrecoverablefast_1**(1/2))/N_totalobservablefast_1)*100
sigmafast_10 = ((N_totalrecoverablefast_10**(1/2))/N_totalobservablefast_10)*100
sigmafast_30 = ((N_totalrecoverablefast_30**(1/2))/N_totalobservablefast_30)*100
sigmafast_100 = ((N_totalrecoverablefast_100**(1/2))/N_totalobservablefast_100)*100
sigmafast_1000 = ((N_totalrecoverablefast_1000**(1/2))/N_totalobservablefast_1000)*100
overallrecoverypercent_fast = (N_totalrecoverablefast/N_totalfast)*100
overallrecoverypercent_fast_03 = (N_totalrecoverablefast_03/N_totalfast_03)*100
overallrecoverypercent_fast_1 = (N_totalrecoverablefast_1/N_totalfast_1)*100
overallrecoverypercent_fast_10 = (N_totalrecoverablefast_10/N_totalfast_10)*100
overallrecoverypercent_fast_30 = (N_totalrecoverablefast_30/N_totalfast_30)*100
overallrecoverypercent_fast_100 = (N_totalrecoverablefast_100/N_totalfast_100)*100
overallrecoverypercent_fast_1000 = (N_totalrecoverablefast_1000/N_totalfast_1000)*100
overallsigmafast = ((N_totalrecoverablefast**(1/2))/N_totalfast)*100
overallsigmafast_03 = ((N_totalrecoverablefast_03**(1/2))/N_totalfast_03)*100
overallsigmafast_1 = ((N_totalrecoverablefast_1**(1/2))/N_totalfast_1)*100
overallsigmafast_10 = ((N_totalrecoverablefast_10**(1/2))/N_totalfast_10)*100
overallsigmafast_30 = ((N_totalrecoverablefast_30**(1/2))/N_totalfast_30)*100
overallsigmafast_100 = ((N_totalrecoverablefast_100**(1/2))/N_totalfast_100)*100
overallsigmafast_1000 = ((N_totalrecoverablefast_1000**(1/2))/N_totalfast_1000)*100
wholerecoverypercent_fast22 = (N_totalrecoverablefast22/N_totalobservablefast22)*100
wholerecoverypercent_fast22_03 = (N_totalrecoverablefast22_03/N_totalobservablefast22_03)*100
wholerecoverypercent_fast22_1 = (N_totalrecoverablefast22_1/N_totalobservablefast22_1)*100
wholerecoverypercent_fast22_10 = (N_totalrecoverablefast22_10/N_totalobservablefast22_10)*100
wholerecoverypercent_fast22_30 = (N_totalrecoverablefast22_30/N_totalobservablefast22_30)*100
wholerecoverypercent_fast22_100 = (N_totalrecoverablefast22_100/N_totalobservablefast22_100)*100
wholerecoverypercent_fast22_1000 = (N_totalrecoverablefast22_1000/N_totalobservablefast22_1000)*100
sigmafast22 = ((N_totalrecoverablefast22**(1/2))/N_totalobservablefast22)*100
sigmafast22_03 = ((N_totalrecoverablefast22_03**(1/2))/N_totalobservablefast22_03)*100
sigmafast22_1 = ((N_totalrecoverablefast22_1**(1/2))/N_totalobservablefast22_1)*100
sigmafast22_10 = ((N_totalrecoverablefast22_10**(1/2))/N_totalobservablefast22_10)*100
sigmafast22_30 = ((N_totalrecoverablefast22_30**(1/2))/N_totalobservablefast22_30)*100
sigmafast22_100 = ((N_totalrecoverablefast22_100**(1/2))/N_totalobservablefast22_100)*100
sigmafast22_1000 = ((N_totalrecoverablefast22_1000**(1/2))/N_totalobservablefast22_1000)*100
overallrecoverypercent_fast22 = (N_totalrecoverablefast22/N_totalfast22)*100
overallrecoverypercent_fast22_03 = (N_totalrecoverablefast22_03/N_totalfast22_03)*100
overallrecoverypercent_fast22_1 = (N_totalrecoverablefast22_1/N_totalfast22_1)*100
overallrecoverypercent_fast22_10 = (N_totalrecoverablefast22_10/N_totalfast22_10)*100
overallrecoverypercent_fast22_30 = (N_totalrecoverablefast22_30/N_totalfast22_30)*100
overallrecoverypercent_fast22_100 = (N_totalrecoverablefast22_100/N_totalfast22_100)*100
overallrecoverypercent_fast22_1000 = (N_totalrecoverablefast22_1000/N_totalfast22_1000)*100
overallsigmafast22 = ((N_totalrecoverablefast22**(1/2))/N_totalfast22)*100
overallsigmafast22_03 = ((N_totalrecoverablefast22_03**(1/2))/N_totalfast22_03)*100
overallsigmafast22_1 = ((N_totalrecoverablefast22_1**(1/2))/N_totalfast22_1)*100
overallsigmafast22_10 = ((N_totalrecoverablefast22_10**(1/2))/N_totalfast22_10)*100
overallsigmafast22_30 = ((N_totalrecoverablefast22_30**(1/2))/N_totalfast22_30)*100
overallsigmafast22_100 = ((N_totalrecoverablefast22_100**(1/2))/N_totalfast22_100)*100
overallsigmafast22_1000 = ((N_totalrecoverablefast22_1000**(1/2))/N_totalfast22_1000)*100
wholerecoverypercent_fast195 = (N_totalrecoverablefast195/N_totalobservablefast195)*100
wholerecoverypercent_fast195_03 = (N_totalrecoverablefast195_03/N_totalobservablefast195_03)*100
wholerecoverypercent_fast195_1 = (N_totalrecoverablefast195_1/N_totalobservablefast195_1)*100
wholerecoverypercent_fast195_10 = (N_totalrecoverablefast195_10/N_totalobservablefast195_10)*100
wholerecoverypercent_fast195_30 = (N_totalrecoverablefast195_30/N_totalobservablefast195_30)*100
wholerecoverypercent_fast195_100 = (N_totalrecoverablefast195_100/N_totalobservablefast195_100)*100
wholerecoverypercent_fast195_1000 = (N_totalrecoverablefast195_1000/N_totalobservablefast195_1000)*100
sigmafast195 = ((N_totalrecoverablefast195**(1/2))/N_totalobservablefast195)*100
sigmafast195_03 = ((N_totalrecoverablefast195_03**(1/2))/N_totalobservablefast195_03)*100
sigmafast195_1 = ((N_totalrecoverablefast195_1**(1/2))/N_totalobservablefast195_1)*100
sigmafast195_10 = ((N_totalrecoverablefast195_10**(1/2))/N_totalobservablefast195_10)*100
sigmafast195_30 = ((N_totalrecoverablefast195_30**(1/2))/N_totalobservablefast195_30)*100
sigmafast195_100 = ((N_totalrecoverablefast195_100**(1/2))/N_totalobservablefast195_100)*100
sigmafast195_1000 = ((N_totalrecoverablefast195_1000**(1/2))/N_totalobservablefast195_1000)*100
overallrecoverypercent_fast195 = (N_totalrecoverablefast195/N_totalfast195)*100
overallrecoverypercent_fast195_03 = (N_totalrecoverablefast195_03/N_totalfast195_03)*100
overallrecoverypercent_fast195_1 = (N_totalrecoverablefast195_1/N_totalfast195_1)*100
overallrecoverypercent_fast195_10 = (N_totalrecoverablefast195_10/N_totalfast195_10)*100
overallrecoverypercent_fast195_30 = (N_totalrecoverablefast195_30/N_totalfast195_30)*100
overallrecoverypercent_fast195_100 = (N_totalrecoverablefast195_100/N_totalfast195_100)*100
overallrecoverypercent_fast195_1000 = (N_totalrecoverablefast195_1000/N_totalfast195_1000)*100
overallsigmafast195 = ((N_totalrecoverablefast195**(1/2))/N_totalfast195)*100
overallsigmafast195_03 = ((N_totalrecoverablefast195_03**(1/2))/N_totalfast195_03)*100
overallsigmafast195_1 = ((N_totalrecoverablefast195_1**(1/2))/N_totalfast195_1)*100
overallsigmafast195_10 = ((N_totalrecoverablefast195_10**(1/2))/N_totalfast195_10)*100
overallsigmafast195_30 = ((N_totalrecoverablefast195_30**(1/2))/N_totalfast195_30)*100
overallsigmafast195_100 = ((N_totalrecoverablefast195_100**(1/2))/N_totalfast195_100)*100
overallsigmafast195_1000 = ((N_totalrecoverablefast195_1000**(1/2))/N_totalfast195_1000)*100\
print("N_totalfast = ", N_totalfast, "and in log = ", np.log10(N_totalfast), "**** N_totalobservablefast = ", N_totalobservablefast, "and in log = ", np.log10(N_totalobservablefast), "**** N_totalrecoverablefast = ", N_totalrecoverablefast, "and in log = ", np.log10(N_totalrecoverablefast))
print("N_totalfast_03 = ", N_totalfast_03, "and in log = ", np.log10(N_totalfast_03), "**** N_totalobservablefast_03 = ", N_totalobservablefast_03, "and in log = ", np.log10(N_totalobservablefast_03), "**** N_totalrecoverablefast_03 = ", N_totalrecoverablefast_03, "and in log = ", np.log10(N_totalrecoverablefast_03))
print("N_totalfast_1 = ", N_totalfast_1, "and in log = ", np.log10(N_totalfast_1), "**** N_totalobservablefast_1 = ", N_totalobservablefast_1, "and in log = ", np.log10(N_totalobservablefast_1), "**** N_totalrecoverablefast_1 = ", N_totalrecoverablefast_1, "and in log = ", np.log10(N_totalrecoverablefast_1))
print("N_totalfast_10 = ", N_totalfast_10, "and in log = ", np.log10(N_totalfast_10), "**** N_totalobservablefast_10 = ", N_totalobservablefast_10, "and in log = ", np.log10(N_totalobservablefast_10), "**** N_totalrecoverablefast_10 = ", N_totalrecoverablefast_10, "and in log = ", np.log10(N_totalrecoverablefast_10))
print("N_totalfast_30 = ", N_totalfast_30, "and in log = ", np.log10(N_totalfast_30), "**** N_totalobservablefast_30 = ", N_totalobservablefast_30, "and in log = ", np.log10(N_totalobservablefast_30), "**** N_totalrecoverablefast_30 = ", N_totalrecoverablefast_30, "and in log = ", np.log10(N_totalrecoverablefast_30))
print("N_totalfast_100 = ", N_totalfast_100, "and in log = ", np.log10(N_totalfast_100), "**** N_totalobservablefast_100 = ", N_totalobservablefast_100, "and in log = ", np.log10(N_totalobservablefast_100), "**** N_totalrecoverablefast_100 = ", N_totalrecoverablefast_100, "and in log = ", np.log10(N_totalrecoverablefast_100))
print("N_totalfast_1000 = ", N_totalfast_1000, "and in log = ", np.log10(N_totalfast_1000), "**** N_totalobservablefast_1000 = ", N_totalobservablefast_1000, "and in log = ", np.log10(N_totalobservablefast_1000), "**** N_totalrecoverablefast_1000 = ", N_totalrecoverablefast_1000, "and in log = ", np.log10(N_totalrecoverablefast_1000))
print("********************************")
print("wholerecoverypercent_fast = $", wholerecoverypercent_fast, "/pm", sigmafast, "$")
print("wholerecoverypercent_fast_03 = $", wholerecoverypercent_fast_03, "/pm", sigmafast_03, "$")
print("wholerecoverypercent_fast_1 = $", wholerecoverypercent_fast_1, "/pm", sigmafast_1, "$")
print("wholerecoverypercent_fast_10 = $", wholerecoverypercent_fast_10, "/pm", sigmafast_10, "$")
print("wholerecoverypercent_fast_30 = $", wholerecoverypercent_fast_30, "/pm", sigmafast_30, "$")
print("wholerecoverypercent_fast_100 = $", wholerecoverypercent_fast_100, "/pm", sigmafast_100, "$")
print("wholerecoverypercent_fast_1000 = $", wholerecoverypercent_fast_1000, "/pm", sigmafast_1000, "$")
print("********************************")
print("overallrecoverypercent_fast = $", overallrecoverypercent_fast, "/pm", overallsigmafast, "$")
print("overallrecoverypercent_fast_03 = $", overallrecoverypercent_fast_03, "/pm", overallsigmafast_03, "$")
print("overallrecoverypercent_fast_1 = $", overallrecoverypercent_fast_1, "/pm", overallsigmafast_1, "$")
print("overallrecoverypercent_fast_10 = $", overallrecoverypercent_fast_10, "/pm", overallsigmafast_10, "$")
print("overallrecoverypercent_fast_30 = $", overallrecoverypercent_fast_30, "/pm", overallsigmafast_30, "$")
print("overallrecoverypercent_fast_100 = $", overallrecoverypercent_fast_100, "/pm", overallsigmafast_100, "$")
print("overallrecoverypercent_fast_1000 = $", overallrecoverypercent_fast_1000, "/pm", overallsigmafast_1000, "$")
print("################################")
print("N_totalfast22 = ", N_totalfast22, "and in log = ", np.log10(N_totalfast22), "**** N_totalobservablefast22 = ", N_totalobservablefast22, "and in log = ", np.log10(N_totalobservablefast22), "**** N_totalrecoverablefast22 = ", N_totalrecoverablefast22, "and in log = ", np.log10(N_totalrecoverablefast22))
print("N_totalfast22_03 = ", N_totalfast22_03, "and in log = ", np.log10(N_totalfast22_03), "**** N_totalobservablefast22_03 = ", N_totalobservablefast22_03, "and in log = ", np.log10(N_totalobservablefast22_03), "**** N_totalrecoverablefast22_03 = ", N_totalrecoverablefast22_03, "and in log = ", np.log10(N_totalrecoverablefast22_03))
print("N_totalfast22_1 = ", N_totalfast22_1, "and in log = ", np.log10(N_totalfast22_1), "**** N_totalobservablefast22_1 = ", N_totalobservablefast22_1, "and in log = ", np.log10(N_totalobservablefast22_1), "**** N_totalrecoverablefast22_1 = ", N_totalrecoverablefast22_1, "and in log = ", np.log10(N_totalrecoverablefast22_1))
print("N_totalfast22_10 = ", N_totalfast22_10, "and in log = ", np.log10(N_totalfast22_10), "**** N_totalobservablefast22_10 = ", N_totalobservablefast22_10, "and in log = ", np.log10(N_totalobservablefast22_10), "**** N_totalrecoverablefast22_10 = ", N_totalrecoverablefast22_10, "and in log = ", np.log10(N_totalrecoverablefast22_10))
print("N_totalfast22_30 = ", N_totalfast22_30, "and in log = ", np.log10(N_totalfast22_30), "**** N_totalobservablefast22_30 = ", N_totalobservablefast22_30, "and in log = ", np.log10(N_totalobservablefast22_30), "**** N_totalrecoverablefast22_30 = ", N_totalrecoverablefast22_30, "and in log = ", np.log10(N_totalrecoverablefast22_30))
print("N_totalfast22_100 = ", N_totalfast22_100, "and in log = ", np.log10(N_totalfast22_100), "**** N_totalobservablefast22_100 = ", N_totalobservablefast22_100, "and in log = ", np.log10(N_totalobservablefast22_100), "**** N_totalrecoverablefast22_100 = ", N_totalrecoverablefast22_100, "and in log = ", np.log10(N_totalrecoverablefast22_100))
print("N_totalfast22_1000 = ", N_totalfast22_1000, "and in log = ", np.log10(N_totalfast22_1000), "**** N_totalobservablefast22_1000 = ", N_totalobservablefast22_1000, "and in log = ", np.log10(N_totalobservablefast22_1000), "**** N_totalrecoverablefast22_1000 = ", N_totalrecoverablefast22_1000, "and in log = ", np.log10(N_totalrecoverablefast22_1000))
print("********************************")
print("wholerecoverypercent_fast22 = $", wholerecoverypercent_fast22, "/pm", sigmafast22, "$")
print("wholerecoverypercent_fast22_03 = $", wholerecoverypercent_fast22_03, "/pm", sigmafast22_03, "$")
print("wholerecoverypercent_fast22_1 = $", wholerecoverypercent_fast22_1, "/pm", sigmafast22_1, "$")
print("wholerecoverypercent_fast22_10 = $", wholerecoverypercent_fast22_10, "/pm", sigmafast22_10, "$")
print("wholerecoverypercent_fast22_30 = $", wholerecoverypercent_fast22_30, "/pm", sigmafast22_30, "$")
print("wholerecoverypercent_fast22_100 = $", wholerecoverypercent_fast22_100, "/pm", sigmafast22_100, "$")
print("wholerecoverypercent_fast22_1000 = $", wholerecoverypercent_fast22_1000, "/pm", sigmafast22_1000, "$")
print("********************************")
print("overallrecoverypercent_fast22 = $", overallrecoverypercent_fast22, "/pm", overallsigmafast22, "$")
print("overallrecoverypercent_fast22_03 = $", overallrecoverypercent_fast22_03, "/pm", overallsigmafast22_03, "$")
print("overallrecoverypercent_fast22_1 = $", overallrecoverypercent_fast22_1, "/pm", overallsigmafast22_1, "$")
print("overallrecoverypercent_fast22_10 = $", overallrecoverypercent_fast22_10, "/pm", overallsigmafast22_10, "$")
print("overallrecoverypercent_fast22_30 = $", overallrecoverypercent_fast22_30, "/pm", overallsigmafast22_30, "$")
print("overallrecoverypercent_fast22_100 = $", overallrecoverypercent_fast22_100, "/pm", overallsigmafast22_100, "$")
print("overallrecoverypercent_fast22_1000 = $", overallrecoverypercent_fast22_1000, "/pm", overallsigmafast22_1000, "$")
print("###############################")
print("N_totalfast195 = ", N_totalfast195, "and in log = ", np.log10(N_totalfast195), "**** N_totalobservablefast195 = ", N_totalobservablefast195, "and in log = ", np.log10(N_totalobservablefast195), "**** N_totalrecoverablefast195 = ", N_totalrecoverablefast195, "and in log = ", np.log10(N_totalrecoverablefast195))
print("N_totalfast195_03 = ", N_totalfast195_03, "and in log = ", np.log10(N_totalfast195_03), "**** N_totalobservablefast195_03 = ", N_totalobservablefast195_03, "and in log = ", np.log10(N_totalobservablefast195_03), "**** N_totalrecoverablefast195_03 = ", N_totalrecoverablefast195_03, "and in log = ", np.log10(N_totalrecoverablefast195_03))
print("N_totalfast195_1 = ", N_totalfast195_1, "and in log = ", np.log10(N_totalfast195_1), "**** N_totalobservablefast195_1 = ", N_totalobservablefast195_1, "and in log = ", np.log10(N_totalobservablefast195_1), "**** N_totalrecoverablefast195_1 = ", N_totalrecoverablefast195_1, "and in log = ", np.log10(N_totalrecoverablefast195_1))
print("N_totalfast195_10 = ", N_totalfast195_10, "and in log = ", np.log10(N_totalfast195_10), "**** N_totalobservablefast195_10 = ", N_totalobservablefast195_10, "and in log = ", np.log10(N_totalobservablefast195_10), "**** N_totalrecoverablefast195_10 = ", N_totalrecoverablefast195_10, "and in log = ", np.log10(N_totalrecoverablefast195_10))
print("N_totalfast195_30 = ", N_totalfast195_30, "and in log = ", np.log10(N_totalfast195_30), "**** N_totalobservablefast195_30 = ", N_totalobservablefast195_30, "and in log = ", np.log10(N_totalobservablefast195_30), "**** N_totalrecoverablefast195_30 = ", N_totalrecoverablefast195_30, "and in log = ", np.log10(N_totalrecoverablefast195_30))
print("N_totalfast195_100 = ", N_totalfast195_100, "and in log = ", np.log10(N_totalfast195_100), "**** N_totalobservablefast195_100 = ", N_totalobservablefast195_100, "and in log = ", np.log10(N_totalobservablefast195_100), "**** N_totalrecoverablefast195_100 = ", N_totalrecoverablefast195_100, "and in log = ", np.log10(N_totalrecoverablefast195_100))
print("N_totalfast195_1000 = ", N_totalfast195_1000, "and in log = ", np.log10(N_totalfast195_1000), "**** N_totalobservablefast195_1000 = ", N_totalobservablefast195_1000, "and in log = ", np.log10(N_totalobservablefast195_1000), "**** N_totalrecoverablefast195_1000 = ", N_totalrecoverablefast195_1000, "and in log = ", np.log10(N_totalrecoverablefast195_1000))
print("********************************")
print("wholerecoverypercent_fast195 = $", wholerecoverypercent_fast195, "/pm", sigmafast195, "$")
print("wholerecoverypercent_fast195_03 = $", wholerecoverypercent_fast195_03, "/pm", sigmafast195_03, "$")
print("wholerecoverypercent_fast195_1 = $", wholerecoverypercent_fast195_1, "/pm", sigmafast195_1, "$")
print("wholerecoverypercent_fast195_10 = $", wholerecoverypercent_fast195_10, "/pm", sigmafast195_10, "$")
print("wholerecoverypercent_fast195_30 = $", wholerecoverypercent_fast195_30, "/pm", sigmafast195_30, "$")
print("wholerecoverypercent_fast195_100 = $", wholerecoverypercent_fast195_100, "/pm", sigmafast195_100, "$")
print("wholerecoverypercent_fast195_1000 = $", wholerecoverypercent_fast195_1000, "/pm", sigmafast195_1000, "$")
print("********************************")
print("overallrecoverypercent_fast195 = $", overallrecoverypercent_fast195, "/pm", overallsigmafast195, "$")
print("overallrecoverypercent_fast195_03 = $", overallrecoverypercent_fast195_03, "/pm", overallsigmafast195_03, "$")
print("overallrecoverypercent_fast195_1 = $", overallrecoverypercent_fast195_1, "/pm", overallsigmafast195_1, "$")
print("overallrecoverypercent_fast195_10 = $", overallrecoverypercent_fast195_10, "/pm", overallsigmafast195_10, "$")
print("overallrecoverypercent_fast195_30 = $", overallrecoverypercent_fast195_30, "/pm", overallsigmafast195_30, "$")
print("overallrecoverypercent_fast195_100 = $", overallrecoverypercent_fast195_100, "/pm", overallsigmafast195_100, "$")
print("overallrecoverypercent_fast195_1000 = $", overallrecoverypercent_fast195_1000, "/pm", overallsigmafast195_1000, "$")
print("#############################")
print("binarypercent_22 = $", (N_totalfast22/N_totalfast)*100, "/pm", ((N_totalfast22**(1/2))/N_totalfast)*100, "$")
print("binarypercent_195 = $", (N_totalfast195/N_totalfast)*100, "/pm", ((N_totalfast195**(1/2))/N_totalfast)*100, "$")
print("binarypercent_03 = $", (N_totalfast_03/N_totalfast)*100, "/pm", ((N_totalfast_03**(1/2))/N_totalfast)*100, "$")
print("binarypercent_1 = $", (N_totalfast_1/N_totalfast)*100, "/pm", ((N_totalfast_1**(1/2))/N_totalfast)*100, "$")
print("binarypercent_10 = $", (N_totalfast_10/N_totalfast)*100, "/pm", ((N_totalfast_10**(1/2))/N_totalfast)*100, "$")
print("binarypercent_30 = $", (N_totalfast_30/N_totalfast)*100, "/pm", ((N_totalfast_30**(1/2))/N_totalfast)*100, "$")
print("binarypercent_100 = $", (N_totalfast_100/N_totalfast)*100, "/pm", ((N_totalfast_100**(1/2))/N_totalfast)*100, "$")
print("binarypercent_1000 = $", (N_totalfast_1000/N_totalfast)*100, "/pm", ((N_totalfast_1000**(1/2))/N_totalfast)*100, "$")
print("observablepercent_03 = $", (N_totalobservablefast_03/N_totalfast_03)*100, "/pm", ((N_totalobservablefast_03**(1/2))/N_totalfast_03)*100, "$")
print("observablepercent_1 = $", (N_totalobservablefast_1/N_totalfast_1)*100, "/pm", ((N_totalobservablefast_1**(1/2))/N_totalfast_1)*100, "$")
print("observablepercent_10 = $", (N_totalobservablefast_10/N_totalfast_10)*100, "/pm", ((N_totalobservablefast_10**(1/2))/N_totalfast_10)*100, "$")
print("observablepercent_30 = $", (N_totalobservablefast_30/N_totalfast_30)*100, "/pm", ((N_totalobservablefast_30**(1/2))/N_totalfast_30)*100, "$")
print("observablepercent_100 = $", (N_totalobservablefast_100/N_totalfast_100)*100, "/pm", ((N_totalobservablefast_100**(1/2))/N_totalfast_100)*100, "$")
print("observablepercent_1000 = $", (N_totalobservablefast_1000/N_totalfast_1000)*100, "/pm", ((N_totalobservablefast_1000**(1/2))/N_totalfast_1000)*100, "$")
print("observablepercent = $", (N_totalobservablefast/N_totalfast)*100, "/pm", ((N_totalobservablefast**(1/2))/N_totalfast)*100, "$")
print("observablepercent22 = $", (N_totalobservablefast22/N_totalfast22)*100, "/pm", ((N_totalobservablefast22**(1/2))/N_totalfast22)*100, "$")
print("observablepercent195 = $", (N_totalobservablefast195/N_totalfast195)*100, "/pm", ((N_totalobservablefast195**(1/2))/N_totalfast195)*100, "$")
for fileobsDist_ in sorted(allFiles_obsDist):
filename = fileobsDist_[77:] #when file path no longer has /old in it, will be fileobsDist_[73:]
fileid = filename.strip('output_file.csv')
print ("I'm starting " + fileid)
datobsDist = pd.read_csv(fileobsDist_, sep = ',', header=2)
PeriodIn = datobsDist['p'] # input period -- 'p' in data file
##########################################################
datobsDist1 = pd.read_csv(fileobsDist_, sep = ',', header=0, nrows=1)
N_tri = datobsDist1["NstarsTRILEGAL"][0]
Nall = len(PeriodIn)
m1hAll0, m1b = np.histogram(datobsDist["m1"], bins=mbins)
dm1 = np.diff(m1b)
m1val = m1b[:-1] + dm1/2.
fb = np.sum(m1hAll0/Nall*fbFit(m1val))
N_mult = N_tri*fb
##########################################################
if len(PeriodIn) == 0.:
continue
if N_tri == 0:
continue
else:
PeriodOut = datobsDist['LSM_PERIOD'] #LSM_PERIOD in data file
appMagMean = datobsDist['appMagMean'] #apparent magnitude, will use to make cuts for 24 (default), 22, and then Kepler's range (?? -- brighter than LSST can manage-- to 19) OR 19.5 (SNR = 10)
observable = datobsDist.loc[PeriodOut != -999].index
observable_03 = datobsDist.loc[(PeriodIn <= 0.3) & (PeriodOut != -999)].index
observable_1 = datobsDist.loc[(PeriodIn <= 1) & (PeriodOut != -999)].index
observable_10 = datobsDist.loc[(PeriodIn <= 10) & (PeriodOut != -999)].index
observable_30 = datobsDist.loc[(PeriodIn <= 30) & (PeriodOut != -999)].index
observable_100 = datobsDist.loc[(PeriodIn <= 100) & (PeriodOut != -999)].index
observable_1000 = datobsDist.loc[(PeriodIn <= 1000) & (PeriodOut != -999)].index
observable_22 = datobsDist.loc[(PeriodOut != -999) & (appMagMean <= 22.)].index
observable_03_22 = datobsDist.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_1_22 = datobsDist.loc[(PeriodIn <= 1) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_10_22 = datobsDist.loc[(PeriodIn <= 10) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_30_22 = datobsDist.loc[(PeriodIn <= 30) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_100_22 = datobsDist.loc[(PeriodIn <= 100) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_1000_22 = datobsDist.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_195 = datobsDist.loc[(PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_03_195 = datobsDist.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_1_195 = datobsDist.loc[(PeriodIn <= 1) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_10_195 = datobsDist.loc[(PeriodIn <= 10) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_30_195 = datobsDist.loc[(PeriodIn <= 30) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_100_195 = datobsDist.loc[(PeriodIn <= 100) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_1000_195 = datobsDist.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
fullP = abs(PeriodOut - PeriodIn)/PeriodIn
halfP = abs(PeriodOut - 0.5*PeriodIn)/(0.5*PeriodIn)
twiceP = abs(PeriodOut - 2*PeriodIn)/(2*PeriodIn)
recoverable = datobsDist.loc[(PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_03 = datobsDist.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_1 = datobsDist.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_10 = datobsDist.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_30 = datobsDist.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_100 = datobsDist.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_1000 = datobsDist.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_22 = datobsDist.loc[(PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_03_22 = datobsDist.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_1_22 = datobsDist.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_10_22 = datobsDist.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_30_22 = datobsDist.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_100_22 = datobsDist.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_1000_22 = datobsDist.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_195 = datobsDist.loc[(PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_03_195 = datobsDist.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_1_195 = datobsDist.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_10_195 = datobsDist.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_30_195 = datobsDist.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_100_195 = datobsDist.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_1000_195 = datobsDist.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((fullP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
P03 = datobsDist.loc[PeriodIn <= 0.3].index
P1 = datobsDist.loc[PeriodIn <= 1].index
P10 = datobsDist.loc[PeriodIn <= 10].index
P30 = datobsDist.loc[PeriodIn <= 30].index
P100 = datobsDist.loc[PeriodIn <= 100].index
P1000 = datobsDist.loc[PeriodIn <= 1000].index
P_22 = datobsDist.loc[appMagMean <= 22.].index
P03_22 = datobsDist.loc[(PeriodIn <= 0.3) & (appMagMean <= 22.)].index
P1_22 = datobsDist.loc[(PeriodIn <= 1) & (appMagMean <= 22.)].index
P10_22 = datobsDist.loc[(PeriodIn <= 10) & (appMagMean <= 22.)].index
P30_22 = datobsDist.loc[(PeriodIn <= 30) & (appMagMean <= 22.)].index
P100_22 = datobsDist.loc[(PeriodIn <= 100) & (appMagMean <= 22.)].index
P1000_22 = datobsDist.loc[(PeriodIn <= 1000) & (appMagMean <= 22.)].index
P_195 = datobsDist.loc[appMagMean <= 19.5].index
P03_195 = datobsDist.loc[(PeriodIn <= 0.3) & (appMagMean <= 19.5)].index
P1_195 = datobsDist.loc[(PeriodIn <= 1) & (appMagMean <= 19.5)].index
P10_195 = datobsDist.loc[(PeriodIn <= 10) & (appMagMean <= 19.5)].index
P30_195 = datobsDist.loc[(PeriodIn <= 30) & (appMagMean <= 19.5)].index
P100_195 = datobsDist.loc[(PeriodIn <= 100) & (appMagMean <= 19.5)].index
P1000_195 = datobsDist.loc[(PeriodIn <= 1000) & (appMagMean <= 19.5)].index
N_all = (len(PeriodIn)/len(PeriodIn))*N_mult
N_all03 = (len(P03)/len(PeriodIn))*N_mult
N_all1 = (len(P1)/len(PeriodIn))*N_mult
N_all10 = (len(P10)/len(PeriodIn))*N_mult
N_all30 = (len(P30)/len(PeriodIn))*N_mult
N_all100 = (len(P100)/len(PeriodIn))*N_mult
N_all1000 = (len(P1000)/len(PeriodIn))*N_mult
N_all_22 = (len(P_22)/len(PeriodIn))*N_mult
N_all03_22 = (len(P03_22)/len(PeriodIn))*N_mult
N_all1_22 = (len(P1_22)/len(PeriodIn))*N_mult
N_all10_22 = (len(P10_22)/len(PeriodIn))*N_mult
N_all30_22 = (len(P30_22)/len(PeriodIn))*N_mult
N_all100_22 = (len(P100_22)/len(PeriodIn))*N_mult
N_all1000_22 = (len(P1000_22)/len(PeriodIn))*N_mult
N_all_195 = (len(P_195)/len(PeriodIn))*N_mult
N_all03_195 = (len(P03_195)/len(PeriodIn))*N_mult
N_all1_195 = (len(P1_195)/len(PeriodIn))*N_mult
N_all10_195 = (len(P10_195)/len(PeriodIn))*N_mult
N_all30_195 = (len(P30_195)/len(PeriodIn))*N_mult
N_all100_195 = (len(P100_195)/len(PeriodIn))*N_mult
N_all1000_195 = (len(P1000_195)/len(PeriodIn))*N_mult
N_obs = (len(observable)/len(PeriodIn))*N_mult
N_obs03 = (len(observable_03)/len(PeriodIn))*N_mult
N_obs1 = (len(observable_1)/len(PeriodIn))*N_mult
N_obs10 = (len(observable_10)/len(PeriodIn))*N_mult
N_obs30 = (len(observable_30)/len(PeriodIn))*N_mult
N_obs100 = (len(observable_100)/len(PeriodIn))*N_mult
N_obs1000 = (len(observable_1000)/len(PeriodIn))*N_mult
N_obs_22 = (len(observable_22)/len(PeriodIn))*N_mult
N_obs03_22 = (len(observable_03_22)/len(PeriodIn))*N_mult
N_obs1_22 = (len(observable_1_22)/len(PeriodIn))*N_mult
N_obs10_22 = (len(observable_10_22)/len(PeriodIn))*N_mult
N_obs30_22 = (len(observable_30_22)/len(PeriodIn))*N_mult
N_obs100_22 = (len(observable_100_22)/len(PeriodIn))*N_mult
N_obs1000_22 = (len(observable_1000_22)/len(PeriodIn))*N_mult
N_obs_195 = (len(observable_195)/len(PeriodIn))*N_mult
N_obs03_195 = (len(observable_03_195)/len(PeriodIn))*N_mult
N_obs1_195 = (len(observable_1_195)/len(PeriodIn))*N_mult
N_obs10_195 = (len(observable_10_195)/len(PeriodIn))*N_mult
N_obs30_195 = (len(observable_30_195)/len(PeriodIn))*N_mult
N_obs100_195 = (len(observable_100_195)/len(PeriodIn))*N_mult
N_obs1000_195 = (len(observable_1000_195)/len(PeriodIn))*N_mult
N_rec = (len(recoverable)/len(PeriodIn))*N_mult
N_rec03 = (len(recoverable_03)/len(PeriodIn))*N_mult
N_rec1 = (len(recoverable_1)/len(PeriodIn))*N_mult
N_rec10 = (len(recoverable_10)/len(PeriodIn))*N_mult
N_rec30 = (len(recoverable_30)/len(PeriodIn))*N_mult
N_rec100 = (len(recoverable_100)/len(PeriodIn))*N_mult
N_rec1000 = (len(recoverable_1000)/len(PeriodIn))*N_mult
N_rec_22 = (len(recoverable_22)/len(PeriodIn))*N_mult
N_rec03_22 = (len(recoverable_03_22)/len(PeriodIn))*N_mult
N_rec1_22 = (len(recoverable_1_22)/len(PeriodIn))*N_mult
N_rec10_22 = (len(recoverable_10_22)/len(PeriodIn))*N_mult
N_rec30_22 = (len(recoverable_30_22)/len(PeriodIn))*N_mult
N_rec100_22 = (len(recoverable_100_22)/len(PeriodIn))*N_mult
N_rec1000_22 = (len(recoverable_1000_22)/len(PeriodIn))*N_mult
N_rec_195 = (len(recoverable_195)/len(PeriodIn))*N_mult
N_rec03_195 = (len(recoverable_03_195)/len(PeriodIn))*N_mult
N_rec1_195 = (len(recoverable_1_195)/len(PeriodIn))*N_mult
N_rec10_195 = (len(recoverable_10_195)/len(PeriodIn))*N_mult
N_rec30_195 = (len(recoverable_30_195)/len(PeriodIn))*N_mult
N_rec100_195 = (len(recoverable_100_195)/len(PeriodIn))*N_mult
N_rec1000_195 = (len(recoverable_1000_195)/len(PeriodIn))*N_mult
N_totalobsDist_array.append(float(N_all))
N_totalobservableobsDist_array.append(float(N_obs))
N_totalrecoverableobsDist_array.append(float(N_rec))
N_totalobsDist_array_03.append(float(N_all03))
N_totalobservableobsDist_array_03.append(float(N_obs03))
N_totalrecoverableobsDist_array_03.append(float(N_rec03))
N_totalobsDist_array_1.append(float(N_all1))
N_totalobservableobsDist_array_1.append(float(N_obs1))
N_totalrecoverableobsDist_array_1.append(float(N_rec1))
N_totalobsDist_array_10.append(float(N_all10))
N_totalobservableobsDist_array_10.append(float(N_obs10))
N_totalrecoverableobsDist_array_10.append(float(N_rec10))
N_totalobsDist_array_30.append(float(N_all30))
N_totalobservableobsDist_array_30.append(float(N_obs30))
N_totalrecoverableobsDist_array_30.append(float(N_rec30))
N_totalobsDist_array_100.append(float(N_all100))
N_totalobservableobsDist_array_100.append(float(N_obs100))
N_totalrecoverableobsDist_array_100.append(float(N_rec100))
N_totalobsDist_array_1000.append(float(N_all1000))
N_totalobservableobsDist_array_1000.append(float(N_obs1000))
N_totalrecoverableobsDist_array_1000.append(float(N_rec1000))
N_totalobsDist22_array.append(float(N_all_22))
N_totalobservableobsDist22_array.append(float(N_obs_22))
N_totalrecoverableobsDist22_array.append(float(N_rec_22))
N_totalobsDist22_array_03.append(float(N_all03_22))
N_totalobservableobsDist22_array_03.append(float(N_obs03_22))
N_totalrecoverableobsDist22_array_03.append(float(N_rec03_22))
N_totalobsDist22_array_1.append(float(N_all1_22))
N_totalobservableobsDist22_array_1.append(float(N_obs1_22))
N_totalrecoverableobsDist22_array_1.append(float(N_rec1_22))
N_totalobsDist22_array_10.append(float(N_all10_22))
N_totalobservableobsDist22_array_10.append(float(N_obs10_22))
N_totalrecoverableobsDist22_array_10.append(float(N_rec10_22))
N_totalobsDist22_array_30.append(float(N_all30_22))
N_totalobservableobsDist22_array_30.append(float(N_obs30_22))
N_totalrecoverableobsDist22_array_30.append(float(N_rec30_22))
N_totalobsDist22_array_100.append(float(N_all100_22))
N_totalobservableobsDist22_array_100.append(float(N_obs100_22))
N_totalrecoverableobsDist22_array_100.append(float(N_rec100_22))
N_totalobsDist22_array_1000.append(float(N_all1000_22))
N_totalobservableobsDist22_array_1000.append(float(N_obs1000_22))
N_totalrecoverableobsDist22_array_1000.append(float(N_rec1000_22))
N_totalobsDist195_array.append(float(N_all_195))
N_totalobservableobsDist195_array.append(float(N_obs_195))
N_totalrecoverableobsDist195_array.append(float(N_rec_195))
N_totalobsDist195_array_03.append(float(N_all03_195))
N_totalobservableobsDist195_array_03.append(float(N_obs03_195))
N_totalrecoverableobsDist195_array_03.append(float(N_rec03_195))
N_totalobsDist195_array_1.append(float(N_all1_195))
N_totalobservableobsDist195_array_1.append(float(N_obs1_195))
N_totalrecoverableobsDist195_array_1.append(float(N_rec1_195))
N_totalobsDist195_array_10.append(float(N_all10_195))
N_totalobservableobsDist195_array_10.append(float(N_obs10_195))
N_totalrecoverableobsDist195_array_10.append(float(N_rec10_195))
N_totalobsDist195_array_30.append(float(N_all30_195))
N_totalobservableobsDist195_array_30.append(float(N_obs30_195))
N_totalrecoverableobsDist195_array_30.append(float(N_rec30_195))
N_totalobsDist195_array_100.append(float(N_all100_195))
N_totalobservableobsDist195_array_100.append(float(N_obs100_195))
N_totalrecoverableobsDist195_array_100.append(float(N_rec100_195))
N_totalobsDist195_array_1000.append(float(N_all1000_195))
N_totalobservableobsDist195_array_1000.append(float(N_obs1000_195))
N_totalrecoverableobsDist195_array_1000.append(float(N_rec1000_195))
N_totalobsDist = np.sum(N_totalobsDist_array)
N_totalobsDist_03 = np.sum(N_totalobsDist_array_03)
N_totalobsDist_1 = np.sum(N_totalobsDist_array_1)
N_totalobsDist_10 = np.sum(N_totalobsDist_array_10)
N_totalobsDist_30 = np.sum(N_totalobsDist_array_30)
N_totalobsDist_100 = np.sum(N_totalobsDist_array_100)
N_totalobsDist_1000 = np.sum(N_totalobsDist_array_1000)
N_totalobservableobsDist = np.sum(N_totalobservableobsDist_array)
N_totalobservableobsDist_03 = np.sum(N_totalobservableobsDist_array_03)
N_totalobservableobsDist_1 = np.sum(N_totalobservableobsDist_array_1)
N_totalobservableobsDist_10 = np.sum(N_totalobservableobsDist_array_10)
N_totalobservableobsDist_30 = np.sum(N_totalobservableobsDist_array_30)
N_totalobservableobsDist_100 = np.sum(N_totalobservableobsDist_array_100)
N_totalobservableobsDist_1000 = np.sum(N_totalobservableobsDist_array_1000)
N_totalrecoverableobsDist = np.sum(N_totalrecoverableobsDist_array)
N_totalrecoverableobsDist_03 = np.sum(N_totalrecoverableobsDist_array_03)
N_totalrecoverableobsDist_1 = np.sum(N_totalrecoverableobsDist_array_1)
N_totalrecoverableobsDist_10 = np.sum(N_totalrecoverableobsDist_array_10)
N_totalrecoverableobsDist_30 = np.sum(N_totalrecoverableobsDist_array_30)
N_totalrecoverableobsDist_100 = np.sum(N_totalrecoverableobsDist_array_100)
N_totalrecoverableobsDist_1000 = np.sum(N_totalrecoverableobsDist_array_1000)
N_totalobsDist22 = np.sum(N_totalobsDist22_array)
N_totalobsDist22_03 = np.sum(N_totalobsDist22_array_03)
N_totalobsDist22_1 = np.sum(N_totalobsDist22_array_1)
N_totalobsDist22_10 = np.sum(N_totalobsDist22_array_10)
N_totalobsDist22_30 = np.sum(N_totalobsDist22_array_30)
N_totalobsDist22_100 = np.sum(N_totalobsDist22_array_100)
N_totalobsDist22_1000 = np.sum(N_totalobsDist22_array_1000)
N_totalobservableobsDist22 = np.sum(N_totalobservableobsDist22_array)
N_totalobservableobsDist22_03 = np.sum(N_totalobservableobsDist22_array_03)
N_totalobservableobsDist22_1 = np.sum(N_totalobservableobsDist22_array_1)
N_totalobservableobsDist22_10 = np.sum(N_totalobservableobsDist22_array_10)
N_totalobservableobsDist22_30 = np.sum(N_totalobservableobsDist22_array_30)
N_totalobservableobsDist22_100 = np.sum(N_totalobservableobsDist22_array_100)
N_totalobservableobsDist22_1000 = np.sum(N_totalobservableobsDist22_array_1000)
N_totalrecoverableobsDist22 = np.sum(N_totalrecoverableobsDist22_array)
N_totalrecoverableobsDist22_03 = np.sum(N_totalrecoverableobsDist22_array_03)
N_totalrecoverableobsDist22_1 = np.sum(N_totalrecoverableobsDist22_array_1)
N_totalrecoverableobsDist22_10 = np.sum(N_totalrecoverableobsDist22_array_10)
N_totalrecoverableobsDist22_30 = | np.sum(N_totalrecoverableobsDist22_array_30) | numpy.sum |
from pynput.keyboard import Key, Controller
from random import randint
import random
import numpy as np
from PIL import ImageGrab as ig
import cv2
import time
from .components import info
from keras.models import Sequential
from keras.layers import Dense, Activation, Conv2D, MaxPooling2D, Flatten, Dropout
from keras.optimizers import SGD
model_built = False
load_saved = False
save_current_pool = 1
current_pool = []
fitness = []
total_models = 12
generation = 1
def save_pool():
for xi in range(total_models):
current_pool[xi].save_weights("Current_Model_Pool/model_new" + str(xi) + ".keras")
print("Saved current pool!")
def model_crossover(model_idx1, model_idx2):
global current_pool
weights1 = current_pool[model_idx1].get_weights()
weights2 = current_pool[model_idx2].get_weights()
weightsnew1 = weights1
weightsnew2 = weights2
weightsnew1[0] = weights2[0]
weightsnew2[0] = weights1[0]
return np.asarray([weightsnew1, weightsnew2])
def model_mutate(weights):
for xi in range(len(weights)):
for yi in range(len(weights[xi])):
if random.uniform(0, 1) > 0.85:
change = random.uniform(-0.5,0.5)
weights[xi][yi] += change
return weights
def predict_action(neural_input, model_num):
neural_input = | np.expand_dims(neural_input,axis=3) | numpy.expand_dims |
# -*- coding: utf-8 -*-
"""
Copyright 2018 <NAME> and <NAME>.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
Please acknowledge the authors when re-using this code and maintain this notice intact.
Code written by <NAME>, implementing ideas from
'Projective simulation with generalization'
<NAME>, <NAME>, <NAME> & <NAME>
Scientific Reports 7, Article number: 14430 (2017) doi:10.1038/s41598-017-14740-y
and
'Projective simulation for artificial intelligence'
<NAME> & <NAME>
Scientific Reports 2, Article number: 400 (2012) doi:10.1038/srep00400
"""
import __future__
import numpy as np
from scipy.sparse import lil_matrix
class PSAgent(object):
""" PS agent implementation """
""" parameters: """
""" num_actions - number of available actions, constant """
""" num_percepts_list - number of percepts in each category, list of constants """
""" generalization - True/False """
""" ps_gamma, ps_eta - constants """
""" policy_type - 'standard' or 'softmax' """
""" ps_alpha - constant """
""" hash_hash_bool - True/False """
""" majority_vote - True/False """
""" majority_time - specifies a trial, after which majorite voting is on """
""" number_votes - number of votes in majority voting """
def __init__(self, num_actions, num_percepts_list, generalization, gamma_damping, eta_glow_damping, policy_type, beta_softmax, hash_hash_bool, majority_vote, majority_time, number_votes):
self.num_actions = num_actions
self.num_categories = len(num_percepts_list)
self.num_percepts_list = num_percepts_list
self.n_percepts = np.prod(num_percepts_list)
self.generalization = generalization
self.hash_hash_bool = hash_hash_bool
self.majority_vote = majority_vote
self.majority_time = majority_time
self.number_votes = number_votes
self.gamma_damping = gamma_damping
self.eta_glow_damping = eta_glow_damping
self.policy_type = policy_type
self.beta_softmax = beta_softmax
self.time = 0 # internal time for majority voting
if self.generalization:
self.max_number_hash_clips = np.prod(np.array(self.num_percepts_list) + 1)
self.adjacency_mat_dim = self.n_percepts + self.max_number_hash_clips + self.num_actions
self.percept_encoding = | np.zeros([self.n_percepts, self.num_categories]) | numpy.zeros |
import os.path
import os
import pickle
import time
import numpy as np
from numpy.testing import assert_almost_equal, assert_equal, assert_allclose
import scipy.stats as stats
# Before removing what appear to be unused imports think twice.
# Some of the tests use eval, which requires the imports.
import refnx.reflect._reflect as _reflect
from refnx.analysis import (
Transform,
Objective,
CurveFitter,
Parameter,
Interval,
Parameters,
)
from refnx.reflect import (
SLD,
ReflectModel,
MixedReflectModel,
reflectivity,
Structure,
Slab,
FresnelTransform,
choose_dq_type,
use_reflect_backend,
)
import refnx.reflect.reflect_model as reflect_model
from refnx.dataset import ReflectDataset
from refnx._lib import MapWrapper
BACKENDS = reflect_model.available_backends()
class TestReflect(object):
def setup_method(self):
self.pth = os.path.dirname(os.path.abspath(__file__))
sio2 = SLD(3.47, name="SiO2")
air = SLD(0, name="air")
si = SLD(2.07, name="Si")
d2o = SLD(6.36, name="D2O")
polymer = SLD(1, name="polymer")
self.structure = air | sio2(100, 2) | si(0, 3)
theoretical = np.loadtxt(os.path.join(self.pth, "theoretical.txt"))
qvals, rvals = np.hsplit(theoretical, 2)
self.qvals = qvals.flatten()
self.rvals = rvals.flatten()
# e361 is an older dataset, but well characterised
self.structure361 = si | sio2(10, 4) | polymer(200, 3) | d2o(0, 3)
self.model361 = ReflectModel(self.structure361, bkg=2e-5)
self.model361.scale.vary = True
self.model361.bkg.vary = True
self.model361.scale.range(0.1, 2)
self.model361.bkg.range(0, 5e-5)
# d2o
self.structure361[-1].sld.real.vary = True
self.structure361[-1].sld.real.range(6, 6.36)
self.structure361[1].thick.vary = True
self.structure361[1].thick.range(5, 20)
self.structure361[2].thick.vary = True
self.structure361[2].thick.range(100, 220)
self.structure361[2].sld.real.vary = True
self.structure361[2].sld.real.range(0.2, 1.5)
e361 = ReflectDataset(os.path.join(self.pth, "e361r.txt"))
self.qvals361, self.rvals361, self.evals361 = (
e361.x,
e361.y,
e361.y_err,
)
def test_abeles(self):
slabs = self.structure.slabs()[..., :4]
for backend in BACKENDS:
# test reflectivity calculation with values generated from Motofit
with use_reflect_backend(backend) as abeles:
calc = abeles(self.qvals, slabs)
assert_almost_equal(calc, self.rvals)
def test_noncontig_abeles(self):
# test for non-contiguous Q values
tempq = self.qvals[0::5]
slabs = self.structure.slabs()[..., :4]
assert tempq.flags["C_CONTIGUOUS"] is False
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc = abeles(tempq, slabs)
assert_almost_equal(calc, self.rvals[0::5])
def test_abeles_multithreaded(self):
slabs = self.structure.slabs()[..., :4]
for backend in BACKENDS:
# test reflectivity calculation with values generated from Motofit
with use_reflect_backend(backend) as abeles:
calc = abeles(self.qvals, slabs, threads=4)
assert_almost_equal(calc, self.rvals)
def test_available_backends(self):
assert "python" in BACKENDS
assert "c" in BACKENDS
import refnx.reflect._creflect as _creflect
import refnx.reflect._reflect as _reflect
assert _reflect.__file__ != _creflect.__file__
if "cython" in BACKENDS:
import refnx.reflect._cyreflect as _cyreflect
assert _creflect.__file__ != _cyreflect.__file__
def test_first_principles(self):
# Test a first principles reflectivity calculation, rather than
# relying on a previous calculation from Motofit code.
# Here we only examine Fresnel reflectivity from an infinitely
# sharp interface, we do not examine a rough surface. This is
# tested by profile slicing in test_structure.
def kn(q, sld_layer, sld_fronting):
# wave vector in a given layer
kvec = np.zeros_like(q, np.complex128)
sld = complex(sld_layer - sld_fronting) * 1.0e-6
kvec[:] = np.sqrt(q[:] ** 2.0 / 4.0 - 4.0 * np.pi * sld)
return kvec
q = np.linspace(0.001, 1.0, 1001)
# Is the fresnel reflectivity correct?
sld1 = 2.07
sld2 = 6.36
# first principles calcn
kf = kn(q, sld1, sld1)
kb = kn(q, sld2, sld1)
reflectance = (kf - kb) / (kf + kb)
reflectivity = reflectance * np.conj(reflectance)
# now from refnx code
struct = SLD(sld1)(0, 0) | SLD(sld2)(0, 0)
slabs = struct.slabs()[..., :4]
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
assert_allclose(abeles(q, slabs), reflectivity, rtol=1e-14)
# reverse the direction
kf = kn(q, sld2, sld2)
kb = kn(q, sld1, sld2)
reflectance = (kf - kb) / (kf + kb)
reflectivity = reflectance * np.conj(reflectance)
# now from refnx code
struct = SLD(sld2)(0, 0) | SLD(sld1)(0, 0)
slabs = struct.slabs()[..., :4]
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
assert_allclose(abeles(q, slabs), reflectivity, rtol=1e-14)
def test_scale_bkg_abeles(self):
s = self.structure.slabs()[..., :4]
calcs = []
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc = abeles(self.qvals, s, scale=2.0)
calcs.append(calc)
for calc in calcs[1:]:
assert_allclose(calc, calcs[0])
calcs = []
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc = abeles(self.qvals, s, scale=0.5, bkg=0.1)
calcs.append(calc)
for calc in calcs[1:]:
assert_allclose(calc, calcs[0])
calcs = []
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc = abeles(self.qvals, s, scale=0.5, bkg=0.1, threads=2)
calcs.append(calc)
for calc in calcs[1:]:
assert_allclose(calc, calcs[0])
"""
@np.testing.decorators.knownfailure
def test_cabeles_parallelised(self):
# I suppose this could fail if someone doesn't have a multicore
# computer
if not TEST_C_REFLECT:
return
coefs = np.array([[0, 0, 0, 0],
[300, 3, 1e-3, 3],
[10, 3.47, 1e-3, 3],
[0, 6.36, 0, 3]])
x = np.linspace(0.01, 0.2, 1000000)
pstart = time.time()
_creflect.abeles(x, coefs, threads=0)
pfinish = time.time()
sstart = time.time()
_creflect.abeles(x, coefs, threads=1)
sfinish = time.time()
print(sfinish - sstart, pfinish - pstart)
assert_(0.7 * (sfinish - sstart) > (pfinish - pstart))
"""
def test_compare_abeles0(self):
# test one layer system against the python implementation
layer0 = np.array([[0, 2.07, 0.01, 3], [0, 6.36, 0.1, 3]])
with use_reflect_backend("python") as abeles:
calc1 = abeles(self.qvals, layer0, scale=0.99, bkg=1e-8)
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc2 = abeles(self.qvals, layer0, scale=0.99, bkg=1e-8)
assert_almost_equal(calc1, calc2)
# test a negative background
with use_reflect_backend("python") as abeles:
calc1 = abeles(self.qvals, layer0, scale=0.99, bkg=-5e-7)
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc2 = abeles(self.qvals, layer0, scale=0.99, bkg=-5e-7)
assert_almost_equal(calc1, calc2)
def test_compare_abeles2(self):
# test two layer system against the python implementation
layer2 = np.array(
[
[0, 2.07, 0.01, 3],
[10, 3.47, 0.01, 3],
[100, 1.0, 0.01, 4],
[0, 6.36, 0.1, 3],
]
)
with use_reflect_backend("python") as abeles:
calc1 = abeles(self.qvals, layer2, scale=0.99, bkg=1e-8)
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc2 = abeles(self.qvals, layer2, scale=0.99, bkg=1e-8)
assert_almost_equal(calc1, calc2)
def test_abeles_absorption(self):
# https://github.com/andyfaff/refl1d_analysis/tree/master/notebooks
q = np.linspace(0.008, 0.05, 500)
depth = [0, 850, 0]
rho = [2.067, 4.3, 6.0]
irho_zero = [0.0, 0.1, 0.0]
refnx_sigma = [np.nan, 35, 5.0]
w_zero = np.c_[depth, rho, irho_zero, refnx_sigma]
with use_reflect_backend("python") as abeles:
calc1 = abeles(q, w_zero)
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc2 = abeles(q, w_zero)
assert_almost_equal(calc1, calc2)
def test_abeles_absorption2(self):
# https://github.com/andyfaff/refl1d_analysis/tree/master/notebooks
# this has an appreciable notch just below the critical edge
refl1d = np.load(os.path.join(self.pth, "absorption.npy"))
q = np.geomspace(0.005, 0.3, 201)
depth = [0, 1200, 0]
rho = [2.07, 4.66, 6.36]
irho = [0, 0.016, 0]
refnx_sigma = [np.nan, 10, 3]
slabs = np.c_[depth, rho, irho, refnx_sigma]
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc = abeles(q, slabs)
assert_almost_equal(calc, refl1d[1])
def test_compare_refl1d(self):
# refl1d calculated with:
# from refl1d import abeles
# x = np.linspace(0.005, 0.5, 1001)
# z = abeles.refl(x / 2,
# [0, 100, 200, 0],
# [2.07, 3.45, 5., 6.],
# irho=[0.0, 0.1, 0.01, 0],
# sigma=[3, 1, 5, 0])
# a = z.real ** 2 + z.imag ** 2
layers = np.array(
[
[0, 2.07, 0, 0],
[100, 3.45, 0.1, 3],
[200, 5.0, 0.01, 1],
[0, 6.0, 0, 5],
]
)
x = np.linspace(0.005, 0.5, 1001)
refl1d = np.load(os.path.join(self.pth, "refl1d.npy"))
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc = abeles(x, layers)
assert_almost_equal(calc, refl1d)
def test_multilayer(self):
x = np.geomspace(0.005, 0.5, 101)
air = np.array([0, 0, 0, 0])
unit_cell = np.array([[30, -2.0, 0, 3], [70, 8.0, 0, 3]])
backing = np.array([0, 2.07, 0.0001, 3])
def get_w(repeats=1):
if repeats:
filling = np.vstack([unit_cell] * repeats)
return np.vstack([air, filling, backing])
else:
return np.vstack([air, backing])
backends = list(BACKENDS)
backends.remove("python")
f_python = reflect_model.get_reflect_backend("python")
for i in range(40):
w = get_w(i)
canonical_r = f_python(x, w)
for backend in backends:
with use_reflect_backend(backend) as abeles:
calc = abeles(x, w)
try:
assert_allclose(
calc, canonical_r, atol=5.0e-15, rtol=8.0e-15
)
except AssertionError as e:
print(backend, i)
raise e
def test_use_reflectivity_backend(self):
import refnx.reflect._creflect as _creflect
import refnx.reflect._reflect as _reflect
reflect_model.abeles = _reflect.abeles
with use_reflect_backend("c") as f:
assert f == _creflect.abeles
assert reflect_model.abeles == _creflect.abeles
assert reflect_model.abeles == _reflect.abeles
# this shouldn't error if pyopencl is not installed
# it should just fall back to 'c'
reflect_model.use_reflect_backend("pyopencl")
def test_reverse(self):
# check that the structure reversal works.
sio2 = SLD(3.47, name="SiO2")
air = SLD(0, name="air")
si = SLD(2.07, name="Si")
structure = si | sio2(100, 3) | air(0, 2)
structure.reverse_structure = True
assert_equal(structure.slabs(), self.structure.slabs())
calc = structure.reflectivity(self.qvals)
assert_almost_equal(calc, self.rvals)
def test_abeles_reshape(self):
# reflectivity should be able to deal with multidimensional input
s = self.structure.slabs()[..., :4]
reshaped_q = np.reshape(self.qvals, (2, 250))
reshaped_r = self.rvals.reshape(2, 250)
for backend in BACKENDS:
with use_reflect_backend(backend) as abeles:
calc = abeles(reshaped_q, s)
assert_equal(calc.shape, reshaped_r.shape)
assert_almost_equal(calc, reshaped_r, 15)
def test_reflectivity_model(self):
# test reflectivity calculation with values generated from Motofit
rff = ReflectModel(self.structure, dq=0)
# the default for number of threads should be -1
assert rff.threads == -1
model = rff.model(self.qvals)
assert_almost_equal(model, self.rvals)
def test_mixed_reflectivity_model(self):
# test that mixed area model works ok.
# should be same as data generated from Motofit
sio2 = SLD(3.47, name="SiO2")
air = SLD(0, name="air")
si = SLD(2.07, name="Si")
s1 = air | sio2(100, 2) | si(0, 3)
s2 = air | sio2(100, 2) | si(0, 3)
mixed_model = MixedReflectModel([s1, s2], [0.4, 0.3], dq=0)
assert_almost_equal(mixed_model(self.qvals), self.rvals * 0.7)
# now try out the mixed model compared to sum of individual models
# with smearing, but no background.
s1 = air | sio2(100, 2) | si(0, 2)
s2 = air | sio2(50, 3) | si(0, 1)
mixed_model = MixedReflectModel([s1, s2], [0.4, 0.3], dq=5, bkg=0)
indiv1 = ReflectModel(s1, bkg=0)
indiv2 = ReflectModel(s2, bkg=0)
assert_almost_equal(
mixed_model(self.qvals),
(0.4 * indiv1(self.qvals) + 0.3 * indiv2(self.qvals)),
)
# now try out the mixed model compared to sum of individual models
# with smearing, and background.
mixed_model.bkg.value = 1e-7
assert_almost_equal(
mixed_model(self.qvals),
(0.4 * indiv1(self.qvals) + 0.3 * indiv2(self.qvals) + 1e-7),
)
def test_parallel_calculator(self):
# test that parallel abeles work with a mapper
q = np.linspace(0.01, 0.5, 1000).reshape(20, 50)
p0 = np.array(
[
[0, 2.07, 0, 0],
[100, 3.47, 0, 3],
[500, -0.5, 1e-3, 3],
[0, 6.36, 0, 3],
]
)
for backend in BACKENDS:
if backend == "pyopencl":
# can't do pyopencl in a multiprocessing.Pool
continue
with use_reflect_backend(backend) as abeles:
wf = Wrapper_fn(abeles, p0)
y = map(wf, q)
with MapWrapper(2) as f:
z = f(wf, q)
assert_equal(z, np.array(list(y)))
def test_parallel_objective(self):
# check that a parallel objective works without issue
# (it could be possible that parallel evaluation fails at a higher
# level in e.g. emcee or in scipy.optimize.differential_evolution)
model = self.model361
model.threads = 2
objective = Objective(
model,
(self.qvals361, self.rvals361, self.evals361),
transform=Transform("logY"),
)
p0 = np.array(objective.varying_parameters())
cov = objective.covar()
walkers = np.random.multivariate_normal(
np.atleast_1d(p0), np.atleast_2d(cov), size=(100)
)
map_logl = np.array(list(map(objective.logl, walkers)))
map_chi2 = np.array(list(map(objective.chisqr, walkers)))
wf = Wrapper_fn2(model.model, p0)
map_mod = np.array(list(map(wf, walkers)))
with MapWrapper(2) as g:
mapw_mod = g(wf, walkers)
mapw_logl = g(objective.logl, walkers)
mapw_chi2 = g(objective.chisqr, walkers)
assert_allclose(mapw_logl, map_logl)
assert_allclose(mapw_chi2, map_chi2)
assert_allclose(mapw_mod, map_mod)
def test_reflectivity_fit(self):
# a smoke test to make sure the reflectivity fit proceeds
model = self.model361
objective = Objective(
model,
(self.qvals361, self.rvals361, self.evals361),
transform=Transform("logY"),
)
fitter = CurveFitter(objective)
with np.errstate(invalid="raise"):
fitter.fit("differential_evolution")
def test_model_pickle(self):
model = self.model361
model.dq = 5.0
model.dq_type = "constant"
pkl = pickle.dumps(model)
unpkl = pickle.loads(pkl)
assert isinstance(unpkl, ReflectModel)
for param in unpkl.parameters.flattened():
try:
assert isinstance(param, Parameter)
except AssertionError:
raise AssertionError(type(param))
assert unpkl.dq_type == "constant"
def test_reflectivity_emcee(self):
model = self.model361
model.dq = 5.0
objective = Objective(
model,
(self.qvals361, self.rvals361, self.evals361),
transform=Transform("logY"),
)
fitter = CurveFitter(objective, nwalkers=100)
assert len(objective.generative().shape) == 1
assert len(objective.residuals().shape) == 1
res = fitter.fit("least_squares")
res_mcmc = fitter.sample(
steps=5, nthin=10, random_state=1, verbose=False
)
mcmc_val = [mcmc_result.median for mcmc_result in res_mcmc]
| assert_allclose(mcmc_val, res.x, rtol=0.05) | numpy.testing.assert_allclose |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 4 18:51:20 2018
@author: cham
"""
import emcee
# %pylab qt5
import matplotlib.pyplot as plt
import numpy as np
from scipy.interpolate import interp1d
from scipy.stats import skewtest, skew, anderson
"""
teff, logg, feh, mags(W1)
varpi, sigma_varpi
"""
def parallax_to_distance(varpi):
"""
:param varpi:
:return:
"""
pass
def dmod_to_parallax(m, M=0.):
"""convert distance modulus to parallax
:param m:
apparent mag
:param M:
absolute mag
:return varpi:
parallax [mas]
"""
return 10. ** (2 - 0.2 * (m - M))
def grid_to_pdf(combined_iso, p_post, colnames=["teff", "logg"],
q=(16, 50, 84)):
# n_quantile x n_colnames
result = np.zeros((len(q), len(colnames)), float)
for i, colname in enumerate(colnames):
# calculate unique values
u_y, inv_ind = np.unique(
combined_iso[colname], return_inverse=True)
# calclulate CDF
u_y = np.append(u_y, u_y[-1] * 2 - u_y[-2])
u_p_post = np.zeros_like(u_y, float)
# u_p_post[inv_ind] = u_p_post[inv_ind] + p_post
for j, _ in enumerate(inv_ind):
u_p_post[_:_ + 2] += 0.5 * p_post[j]
result[:, i] = interp1d(np.cumsum(u_p_post) / np.sum(u_p_post), u_y)(q)
return result
# %%
"""
In this section, I do some tests on normality of varpi(mag).
"""
def lnprob_gauss(x, ivar):
return -0.5 * np.sum(ivar * x ** 2)
def ezchain_gauss(ivar, n_dim=2, n_walkers=100, n_burnin=100, n_chain=1000):
""" get a mcmc-based gaussian sample
Example
-------
>>> import matplotlib.pyplot as plt
>>> c = ezchain_gauss(1, n_dim=1, n_walkers=100, n_chain=1000)
>>> plt.figure()
>>> plt.hist(c.flatchain)
"""
assert n_walkers >= 2 * n_dim
# run MCMC
p0 = [np.random.rand(n_dim) for i in range(n_walkers)]
sampler = emcee.EnsembleSampler(n_walkers, n_dim, lnprob_gauss,
args=[ivar])
pos, prob, state = sampler.run_mcmc(p0, n_burnin)
sampler.reset()
sampler.run_mcmc(pos, n_chain)
return sampler
def test_skewness(dmod=8., test_sigma_mag=np.logspace(-3, 0, 50)):
# sample a gauss
# sampler = ezchain_gauss(1, n_dim=1, n_walkers=100, n_chain=1000)
# flatchain = sampler.flatchain
flatchain = np.random.randn(100000)
# test skewness
skewness_dmod = np.zeros_like(test_sigma_mag)
skewness_varpi = np.zeros_like(test_sigma_mag)
# pvalue
pvalue_dmod = | np.zeros_like(test_sigma_mag) | numpy.zeros_like |
"""
This module is used to call Quantum Espresso simulation and parse its output
The user need to supply a complete input script with single-point scf
calculation, CELL_PARAMETERS, ATOMIC_POSITIONS, nat, ATOMIC_SPECIES
arguments. It is case sensitive. and the nat line should be the first
argument of the line it appears. The user can also opt to the ASE interface instead.
This module will copy the input template to a new file with "_run" suffix,
edit the atomic coordination in the ATOMIC_POSITIONS block and run the similation with the parallel set up given.
"""
import os
from subprocess import call
import time
import numpy as np
from flare import struc
from typing import List
name = "QE"
def run_dft_par(
dft_input,
structure,
dft_loc,
n_cpus=1,
dft_out="pwscf.out",
npool=None,
mpi="mpi",
**dft_kwargs,
):
"""run DFT calculation with given input template
and atomic configurations. if n_cpus == 1, it executes serial run.
:param dft_input: input template file name
:param structure: atomic configuration
:param dft_loc: relative/absolute executable of the DFT code
:param n_cpus: # of CPU for mpi
:param dft_out: output file name
:param npool: not used
:param mpi: not used
:param **dft_wargs: not used
:return: forces
"""
newfilename = edit_dft_input_positions(dft_input, structure)
if npool is None:
dft_command = f"{dft_loc} -i {newfilename}"
else:
dft_command = f"{dft_loc} -nk {npool} -i {newfilename}"
if n_cpus > 1:
if mpi == "mpi":
dft_command = f"mpirun -np {n_cpus} {dft_command}"
else:
dft_command = f"srun -n {n_cpus} --mpi=pmi2 {dft_command}"
with open(dft_out, "w+") as fout:
call(dft_command.split(), stdout=fout)
os.remove(newfilename)
return parse_dft_forces(dft_out)
def run_dft_en_par(dft_input, structure, dft_loc, n_cpus):
"""run DFT calculation with given input template
and atomic configurations. This function is not used atm
if n_cpus == 1, it executes serial run.
:param dft_input: input template file name
:param structure: atomic configuration
:param dft_loc: relative/absolute executable of the DFT code
:param n_cpus: # of CPU for mpi
:param dft_out: output file name
:param npool: not used
:param mpi: not used
:param **dft_wargs: not used
:return: forces, energy
"""
run_qe_path = dft_input
edit_dft_input_positions(run_qe_path, structure)
qe_command = "mpirun -np {n_cpus} {dft_loc} -i {run_qe_path}"
with open("pwscf.out", "w+") as fout:
call(qe_command.split(), stdout=fout)
forces, energy = parse_dft_forces_and_energy("pwscf.out")
return forces, energy
def run_dft_en_npool(qe_input, structure, dft_loc, npool):
run_qe_path = qe_input
edit_dft_input_positions(run_qe_path, structure)
qe_command = "mpirun {0} -npool {1} < {2} > {3}".format(
dft_loc, npool, run_qe_path, "pwscf.out"
)
call(qe_command, shell=True)
forces, energy = parse_dft_forces_and_energy("pwscf.out")
return forces, energy
def parse_dft_input(dft_input: str):
"""parse the input to get information of atomic configuration
:param dft_input: input file name
:return: positions, species, cell, masses
"""
positions = []
species = []
cell = []
with open(dft_input) as f:
lines = f.readlines()
# Find the cell and positions in the output file
cell_index = None
positions_index = None
nat = None
species_index = None
for i, line in enumerate(lines):
if "CELL_PARAMETERS" in line:
cell_index = int(i + 1)
if "ATOMIC_POSITIONS" in line:
positions_index = int(i + 1)
if "nat" in line:
nat = int(line.split("=")[1])
if "ATOMIC_SPECIES" in line:
species_index = int(i + 1)
assert cell_index is not None, "Failed to find cell in input"
assert positions_index is not None, "Failed to find positions in input"
assert nat is not None, "Failed to find number of atoms in input"
assert species_index is not None, "Failed to find atomic species in input"
# Load cell
for i in range(cell_index, cell_index + 3):
cell_line = lines[i].strip()
cell.append(np.fromstring(cell_line, sep=" "))
cell = np.array(cell)
# Check cell IO
assert len(cell) != 0, "Cell failed to load"
assert np.shape(cell) == (3, 3), "Cell failed to load correctly"
# Load positions
for i in range(positions_index, positions_index + nat):
line_string = lines[i].strip().split()
species.append(line_string[0])
pos_string = " ".join(line_string[1:4])
positions.append( | np.fromstring(pos_string, sep=" ") | numpy.fromstring |
import script_tools as st
import registration as reg
import numpy as np
import landmarks
import dist_table as dt
# Windows
#dataset_path = "C:/cygwin64/home/johan/itkAlphaCut/assets/01.png"
#bin_path = "C:/cygwin64/home/johan/itkAlphaCut-release/Release/"
# Linux
dataset_path = "/home/johof680/work/itkAlphaAMD/images/cilia_public_cut_out.png"
bin_path = "/home/johof680/work/itkAlphaAMD-build/"
def main(USE_PYRAMIDS, RANDOMIZE_TRANSFORMS, DO_AFFINE_REGISTRATION, DO_TRANSFORM_LANDMARKS, EVAL_LANDMARKS, metric_name, transformation_size, noise_level, reverse):
out_path = dataset_path
# image extension
im_ext = "tif"
# number of registrations to perform
count = 1000
# create registration object
parallel_count = 6
image_dimensions = 2
r = reg.Registration(parallel_count, bin_path, dim = image_dimensions, enable_logging = True)
out_path1 = "/home/johof680/work/itkAlphaAMD-build/cilia/" + transformation_size + "/" + noise_level + "/"
# Generate random transforms
if RANDOMIZE_TRANSFORMS:
rnd_param = r.get_random_transforms_param_defaults()
if noise_level == "none":
rnd_param["noise"] = "0.0"
elif noise_level == "large":
rnd_param["noise"] = "0.1"
else:
raise "Illegal noise level."
if transformation_size == "small":
rnd_param["rotation"] = "10"
rnd_param["translation"] = "10"
rnd_param["min_rotation"] = "0"
rnd_param["min_translation"] = "0"
elif transformation_size == "medium":
rnd_param["rotation"] = "20"
rnd_param["translation"] = "20"
rnd_param["min_rotation"] = "10"
rnd_param["min_translation"] = "10"
elif transformation_size == "large":
rnd_param["rotation"] = "30"
rnd_param["translation"] = "30"
rnd_param["min_rotation"] = "20"
rnd_param["min_translation"] = "20"
elif transformation_size == "all":
rnd_param["rotation"] = "30"
rnd_param["translation"] = "30"
rnd_param["min_rotation"] = "0"
rnd_param["min_translation"] = "0"
else:
raise "Illegal transformation size."
r.random_transforms(dataset_path, out_path1, count, rnd_param)
st.create_directory(out_path1)
r.run("Random transformations")
in_path = out_path1
if reverse:
out_path1 = out_path1 + metric_name + "_reverse/"
else:
out_path1 = out_path1 + metric_name + "/"
st.create_directory(out_path1)
# Do the registrations
def register(rp, input1_path, input2_path, output_path, metric, cnt):
for i in xrange(cnt):
pth = output_path + ("registration_%d/" % (i+1))
rpar = rp.get_register_param_defaults()
rpar.pop("weights1", None)
rpar.pop("weights2", None)
msk2 = input2_path + "transformed_mask_%d.%s" % (i+1, im_ext)
if reverse:
rpar["mask2"] = "circle"
rpar["mask1"] = msk2
in2 = input1_path + "ref_image_%d.%s" %(i+1, im_ext)
in1 = input2_path + "transformed_image_%d.%s" % (i+1, im_ext)
else:
rpar["mask1"] = "circle"
rpar["mask2"] = msk2
in1 = input1_path + "ref_image_%d.%s" %(i+1, im_ext)
in2 = input2_path + "transformed_image_%d.%s" % (i+1, im_ext)
if USE_PYRAMIDS:
rpar["multiscale_sampling_factors"] = "4x2x1"
rpar["multiscale_smoothing_sigmas"] = "5x3x0"
else:
rpar["multiscale_sampling_factors"] = "1"
rpar["multiscale_smoothing_sigmas"] = "0"
rpar["metric"] = metric
rpar["learning_rate"] = "0.5"
rpar["alpha_outlier_rejection"] = "0.0"
rpar["sampling_fraction"] = "0.1"
rpar["normalization"] = "0.05"
rp.register_affine(in1, in2, pth, rpar)
#def landmark_transform(self, landmarks_in_path, out_path, out_name, transform_path):
def transform_landmarks(rp, landmark_path, landmark_prefix, transform_path_base, cnt):
for i in xrange(cnt):
transform_path = transform_path_base + ("registration_%d/transform_complete.txt" % (i+1))
if reverse:
input_path = landmark_path + landmark_prefix + ".csv"
else:
input_path = landmark_path + landmark_prefix + "_%d.csv" % (i + 1)
out_name = "registered_landmarks_%d.csv" % (i + 1)
rp.landmark_transform(input_path, transform_path_base, out_name, transform_path)
if DO_AFFINE_REGISTRATION:
register(r, in_path, in_path, out_path1, metric_name, count)
r.run("Affine Registration")
if DO_TRANSFORM_LANDMARKS:
if reverse:
transform_landmarks(r, in_path, "ref_landmarks", out_path1, count)
else:
transform_landmarks(r, in_path, "transformed_landmarks", out_path1, count)
r.run("Transform Landmarks")
def eval_landmarks(ref_landmark_path, output_path, cnt):
if reverse:
dists = np.zeros(cnt)
for i in xrange(cnt):
ref_lm = landmarks.read_csv(in_path + "transformed_landmarks_%d.csv" % (i+1), False) #csv_2_np.read_csv(out1_path + "ref_landmarks.csv", False)
tra_lm = landmarks.read_csv(output_path + "registered_landmarks_%d.csv" % (i+1))
dists[i] = landmarks.mean_euclidean(ref_lm, tra_lm)
return (np.mean(dists), np.std(dists), dists, dt.make_distribution(dists))
else:
ref_lm = landmarks.read_csv(ref_landmark_path + "ref_landmarks.csv", False) #csv_2_np.read_csv(out1_path + "ref_landmarks.csv", False)
dists = | np.zeros(cnt) | numpy.zeros |
#!/usr/bin/env python
import os
#os.environ["CUDA_VISIBLE_DEVICES"]="-1"
import numpy as np
from math import sqrt
from numpy import zeros
import re
import math
from .batch_object import batch_object
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
import pdb
import random
import time
from numpy import genfromtxt
#from scipy.spatial import distance
#from PIL import Image
#import pickle
from pathlib import Path
import time
from random import randint
import gc
import csv
from . import datadir
#os.environ['CUDA_VISIBLE_DEVICES'] = ''
np.random.seed(2504)
def main():
import apetype as at
class CLI_Settings(at.ConfigBase):
seq_len: int # Sequence length
tr_dir: str # Directory with training data '.ct' files
settings = CLI_Settings()
# Import tensorflow, after processing CLI_Settings as it prints warnings
import tensorflow as tf
from tensorflow.python.saved_model import builder as saved_model_builder
def conv1d(input, pname, name, kshape, stride=1):
with tf.name_scope(name):
W = tf.get_variable(name=pname+'w_'+name,
shape=kshape)
b = tf.get_variable(name=pname+'bias_' + name,
shape=[kshape[2]])
out = tf.nn.conv1d(input,W,stride=stride, padding='SAME')
out = tf.nn.bias_add(out, b)
out = tf.nn.leaky_relu(out)
#out = tf.nn.relu(out)
return out
def fullyConnected(input, name, output_size):
with tf.name_scope(name):
input_size = input.shape[1:]
input_size = int(np.prod(input_size))
W = tf.get_variable(name='w_'+name,
shape=[input_size, output_size])
b = tf.get_variable(name='bias_'+name,
shape=[output_size])
input = tf.reshape(input, [-1, input_size])
out = tf.add(tf.matmul(input, W), b)
out = tf.nn.leaky_relu(out)
#out = tf.maximum(out, 0.01 * out, name = "forsoft")
return out
def model(x, y, keep_ratio1, keep_ratio2):
dpi = tf.nn.dropout(x, keep_ratio1)
filter_size = 5
lc1 = conv1d(dpi, 'fre_','lc1', [filter_size, 2*max_features, 64])
lc2 = conv1d(lc1, 'fre_', 'lc2', [filter_size, 64, 128])
lc3 = conv1d(lc2, 'fre_', 'lc3', [filter_size, 128, 256])
lc4 = conv1d(lc3, 'fre_', 'lc4', [filter_size, 256, 512])
lc5 = conv1d(lc4, 'fre_', 'lc5', [filter_size, 512, 1024])
lc6 = conv1d(lc5, 'fre_', 'lc6', [filter_size, 1024, 2048])
ml = tf.contrib.layers.flatten(lc6)
dp = tf.nn.dropout(ml, keep_ratio2)
out = fullyConnected(dp, "output_p", seq_len * seq_len)
loss = tf.reduce_mean(tf.squared_difference( y, out))
#vars = tf.trainable_variables()
#l2_loss = tf.add_n([ tf.nn.l2_loss(v) for v in vars if 'bias' not in v.name ])
#loss = tf.add(loss, 0.000001*l2_loss)
return out, loss
def clean_seq(s):
ns = s.upper()
pattern = re.compile(r'\s+')
ns = re.sub(pattern, '', ns)
ns = re.sub(r'[^a-zA-Z]{1}', 'N', ns)
return ns
def encode(ns):
ns = ns.replace("A", "1,0,0,0,")
ns = ns.replace("U", "0,1,0,0,")
ns = ns.replace("G", "0,0,1,0,")
ns = ns.replace("C", "0,0,0,1,")
if re.search('[a-zA-Z]', ns):
#print(s)
#print('Non-standard symbol in sequence - changed to A.')
ns = re.sub("[a-zA-Z]", "0,0,0,0,", ns)
return ns[:-1]
def brun(sess, x, y, a, keep_prob1, keep_prob2):
preds = []
batch_size = 128
number_of_full_batch=int(math.ceil(float(len(a))/batch_size))
for i in range(number_of_full_batch):
preds += list(sess.run(y, feed_dict={x: np.asarray(a[i*batch_size:(i+1)*batch_size]),
keep_prob1: 1.0, keep_prob2: 1.0}))
return preds
max_features = 4
seq_len = settings.seq_len # int(sys.argv[1])
tr_dir = settings.tr_dir # sys.argv[2]
pos_seq = []
raw_seq = []
used_seq = set(['N'*seq_len + '_' + 'N'*seq_len])
dup = 0
seq = ""
small_classes = []
with open(os.path.join(datadir,'small_classes.csv')) as file:
for line in file:
small_classes.append(line.strip())
t_classes = []
with open(os.path.join(datadir,'t_classes.csv')) as file:
for line in file:
t_classes.append(line.strip())
directory = os.fsencode(tr_dir)
x_data = []
y_data = []
y_raw = []
filenames = []
steps = []
ctp = 0
rms = 0
for file in os.listdir(directory):
filename = os.fsdecode(file)
skip_file = False
if filename.endswith(".ct"):
seq=""
prev_nuc = 0
pairs = []
first = True
with open(tr_dir + "/" + filename) as fp:
for cnt, line in enumerate(fp):
if(line.startswith("#")):
continue
if(first):
first = False
continue
values = line.split()
seq = seq + values[1]
if(int(values[0]) != prev_nuc + 1):
rms = rms + 1
skip_file = True
break
prev_nuc = int(values[0])
if(int(values[4])>0):
pairs.append([int(values[2]), int(values[4]) - 1])
if(skip_file):
continue
seq = clean_seq(seq)
#if(len(seq) <= 140):
# continue
a = seq_len - 1
nseq = 'N'*(a) + seq + 'N'*(a)
pos_seq.append(np.fromstring(encode(nseq), dtype=int, sep=",").reshape(-1, 4))
raw_seq.append(nseq)
square_size = len(nseq)
y_cm = | zeros((square_size, square_size)) | numpy.zeros |
from __future__ import print_function
import numpy as np
import sys
import regreg.api as rr
from selection.tests.instance import logistic_instance, gaussian_instance
from selection.approx_ci.selection_map import threshold_score_map
from selection.approx_ci.ci_approx_density import approximate_conditional_density
from selection.randomized.query import naive_confidence_intervals
def approximate_inference(X,
y,
true_mean,
sigma,
threshold = 2.,
seed_n = 0,
lam_frac = 1.,
loss='gaussian',
randomization_scale = 1.):
from selection.api import randomization
n, p = X.shape
np.random.seed(seed_n)
if loss == "gaussian":
lam = lam_frac * np.mean(np.fabs(np.dot(X.T, np.random.standard_normal((n, 2000)))).max(0)) * sigma
loss = rr.glm.gaussian(X, y)
elif loss == "logistic":
lam = lam_frac * np.mean(np.fabs(np.dot(X.T, np.random.binomial(1, 1. / 2, (n, 10000)))).max(0))
loss = rr.glm.logistic(X, y)
active_bool = np.zeros(p, np.bool)
inactive_bool = ~active_bool
randomization = randomization.isotropic_gaussian((p,), scale=randomization_scale)
TS = threshold_score_map(loss,
threshold,
randomization,
active_bool,
inactive_bool,
randomization_scale)
TS.solve_approx()
active = TS._overall
active_set = np.asarray([i for i in range(p) if active[i]])
nactive = np.sum(active)
sys.stderr.write("number of active selected by thresholding" + str(nactive) + "\n")
sys.stderr.write("Active set selected by thresholding" + str(active_set) + "\n")
sys.stderr.write("Observed target" + str(TS.target_observed) + "\n")
if nactive == 0:
return None
else:
true_vec = np.linalg.inv(X[:, active].T.dot(X[:, active])).dot(X[:, active].T).dot(true_mean)
sys.stderr.write("True target to be covered" + str(true_vec) + "\n")
ci_naive = naive_confidence_intervals(np.diag(TS.target_cov), TS.target_observed)
naive_covered = np.zeros(nactive)
naive_risk = np.zeros(nactive)
ci = approximate_conditional_density(TS)
ci.solve_approx()
ci_sel = | np.zeros((nactive, 2)) | numpy.zeros |
from controller import Robot, Motor, DistanceSensor
import math
import cv2
import time
import numpy as np
robot = Robot()
RightMotor = robot.getDevice('right wheel motor')
LeftMotor = robot.getDevice('left wheel motor')
RightMotor.setPosition(float('inf'))
LeftMotor.setPosition(float('inf'))
RightMotor.setVelocity(0.0)
LeftMotor.setVelocity(0.0)
TimeGap = int(robot.getBasicTimeStep())
Distance_sensor = [robot.getDevice('ps0'), robot.getDevice('ps2'), robot.getDevice('ps5'), robot.getDevice('ps7')]
robot.getDevice('ps0').enable(TimeGap)
robot.getDevice('ps2').enable(TimeGap)
robot.getDevice('ps5').enable(TimeGap)
robot.getDevice('ps7').enable(TimeGap)
camera = robot.getDevice('camera')
camera.enable(TimeGap)
def front_distance_1():
return robot.getDevice('ps0').getValue()
def front_distance_2():
return robot.getDevice('ps7').getValue()
def right_distance():
return robot.getDevice('ps2').getValue()
def left_distance():
return robot.getDevice('ps5').getValue()
def green():
lower = | np.array([56, 175, 0]) | numpy.array |
import re
import os
import cv2
import numpy as np
import matplotlib.pyplot as plt
def create_z_stack(path, x1, x2, y1, y2, alpha=1):
Z_stack = np.asarray([None, None])
num_slices = 0
# search for existing stack, else create
try:
print("Trying to load existing Z Stack.")
Z_stack[0] = np.load(path + 'c1/0Z_STACK_c1.npy')
Z_stack[1] = np.load(path + 'c2/0Z_STACK_c2.npy')
except IOError:
print("Z Stack doesn't exist. Creating now.")
slices = [[],[]]
slices[0] = sorted(os.listdir(path+'c1/'), key=lambda z: (int(re.sub('\D', '', z)), z))
slices[1] = sorted(os.listdir(path+'c2/'), key=lambda z: (int(re.sub('\D', '', z)), z))
print(np.asarray(slices).shape)
# loops through slices to create stack using np.vstack
for idx, _ in enumerate(slices):
f_name = ""
if idx == 0:
print("C1 Stack")
f_name = path + "c1/0Z_STACK_c1.npy"
img_path = path + "c1/"
else:
print("C2 Stack")
f_name = path + "c2/0Z_STACK_c2.npy"
img_path = path + "c2/"
for ind, i in enumerate(slices[idx]):
num_slices = len(slices[idx])
if i.endswith('.jpeg') or i.endswith('.png'):
img_name = img_path + i
img = cv2.imread(img_name)[:, :, 0]
img = cv2.bilateralFilter(img, 5, 50, 50)
# img = cv2.erode(img, kernel=cv2.getStructuringElement(cv2.MORPH_ERODE, (3, 3)))
# img = cv2.dilate(img, kernel=cv2.getStructuringElement(cv2.MORPH_DILATE, (3, 3)))
if Z_stack[idx] is None:
Z_stack[idx] = np.expand_dims(img, axis=0)
else:
Z_stack[idx] = np.vstack((Z_stack[idx], np.expand_dims(img, axis=0)))
print("Progress: ", Z_stack[idx].shape, " [%d%%]" % (((ind + 1) / (1.0 * num_slices)) * 100), end="\r")
np.save(f_name, Z_stack[idx], allow_pickle=True)
num_slices = Z_stack[0].shape[0]
yz_cross_sec = {"c1": np.asarray(Z_stack[0][:, :, (x1 + x2) // 2]),
"c2": np.asarray(Z_stack[1][:, :, (x1 + x2) // 2])}
xz_cross_sec = {"c1": np.asarray(Z_stack[0][:, (y1 + y2) // 2, :]),
"c2": np.asarray(Z_stack[1][:, (y1 + y2) // 2, :])}
roi1 = yz_cross_sec["c1"][:, y1:y2]
roi2 = xz_cross_sec["c1"][:, x1:x2]
roi1 = cv2.bilateralFilter(roi1, 3, 50, 50)
roi2 = cv2.bilateralFilter(roi2, 3, 50, 50)
ret, thresh_roi1 = cv2.threshold(roi1, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY)
ret, thresh_roi2 = cv2.threshold(roi2, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY)
window_size1 = int(alpha * thresh_roi1.shape[1] - 1)
window_size2 = int(alpha * thresh_roi2.shape[1] - 1)
thresh_roi1[:, window_size1:thresh_roi1.shape[1] - 1 - window_size1] = 0
thresh_roi2[:, window_size2:thresh_roi2.shape[1] - 1 - window_size2] = 0
analyse_stack1 = thresh_roi1[:, 0:window_size1]
analyse_stack2 = thresh_roi2[:, 0:window_size2]
analyse_stack3 = thresh_roi1[:, thresh_roi1.shape[1] - window_size1:thresh_roi1.shape[1]]
analyse_stack4 = thresh_roi2[:, thresh_roi2.shape[1] - window_size2:thresh_roi2.shape[1]]
analyse_stack1 = (np.sum(analyse_stack1, axis=1) / 255) >= (0.3 * window_size1)
a_s1_2 = np.roll(analyse_stack1, -1)
a_s1_3 = np.roll(analyse_stack1, -2)
stack1 = np.bitwise_and(analyse_stack1, a_s1_2)
stack1 = np.bitwise_and(stack1, a_s1_3)
stack1[-1] = True
val1 = num_slices - np.argmax(np.flip(stack1[:-3], 0))
analyse_stack2 = (np.sum(analyse_stack2, axis=1) / 255) >= (0.3 * window_size2)
a_s2_2 = np.roll(analyse_stack2, -1)
a_s2_3 = np.roll(analyse_stack2, -2)
stack2 = np.bitwise_and(analyse_stack2, a_s2_2)
stack2 = np.bitwise_and(stack2, a_s2_3)
stack2[-1] = True
val2 = num_slices - np.argmax(np.flip(stack2[:-3], 0))
analyse_stack3 = (np.sum(analyse_stack3, axis=1) / 255) >= (0.3 * window_size1)
a_s3_2 = np.roll(analyse_stack3, -1)
a_s3_3 = np.roll(analyse_stack3, -2)
stack3 = np.bitwise_and(analyse_stack3, a_s3_2)
stack3 = np.bitwise_and(stack3, a_s3_3)
stack3[-1] = True
val3 = num_slices - np.argmax( | np.flip(stack3[:-3], 0) | numpy.flip |
#!/usr/bin/env python3
import sys
import logging
import yaml
import pandas as pd
import numpy as np
from collections import defaultdict
from sklearn.model_selection import train_test_split
from sklearn.ensemble import IsolationForest
from sklearn.impute import SimpleImputer
from anoflows.hpo import find_best_flows
from data_loading import load_data
logging.getLogger().setLevel(logging.INFO)
if len(sys.argv) == 1:
logging.error("YAML data specification missing from the command line arguments")
exit(1)
spec_file = sys.argv[1]
df, spec = load_data(spec_file)
max_rows = min(len(df), spec.get("max_rows", 40000))
novelty_detection = spec.get("novelty", True)
normal_classes = spec["normal_classes"]
precision = defaultdict(list)
for rounds in range(spec.get("rounds", 1)):
# random sampling
df = df.sample(n=max_rows, replace=False)
label_col = spec["label_column"]
y = df[label_col].values
other = df.drop(label_col, inplace=False, axis=1)
X = other.values
# imputing
X = SimpleImputer(copy=False).fit_transform(X)
# train/test split
X_train, X_test, y_train, y_test = \
train_test_split(X, y, shuffle=False, test_size=0.5)
if novelty_detection:
keep = np.where(np.isin(y_train, normal_classes))[0]
X_train = X_train[keep, :]
y_train = y_train[keep]
# training
#flows, loss = find_best_flows(X_train, device='cpu', n_trials=1)
from anoflows.anoflow_bagging import AnoFlowBagging
flows = AnoFlowBagging()
flows.fit(X_train)
iforest = IsolationForest().fit(X_train)
# prediction
pred = {
"anoflows": flows.likelihood(X_test),
"iforest": iforest.decision_function(X_test)
}
# evaluation
y_true = np.where(np.isin(y_test, spec["anomaly_classes"]))[0]
ref = np.zeros(len(y_test))
ref[y_true] = 1
k = len(y_true)
for name, y_pred in pred.items():
anomaly_indices = y_pred.argsort()[:k]
prec = ref[anomaly_indices].sum() / k
logging.info("%s: %.1f%% (%d anomalies / %d rows)" % (name, 100*prec, k, len(y_test)))
precision[name].append(prec)
logging.info("* SUMMARY %s", spec_file)
for name, prec in precision.items():
prec = 100 * | np.array(prec) | numpy.array |
try:
import os
if os.environ['BOARD'] == 'Ultra96':
os.environ["DISPLAY"] = ":1"
except KeyError:
pass
import cv2
import time
import signal
import threading
import numpy as np
import multiprocessing
__author__ = "<NAME>"
__email__ = "<EMAIL>"
# this file contains definations for camera controllers
font = cv2.FONT_HERSHEY_SIMPLEX
class SimpleCameraController:
def __init__(self, state_ptr=None, scale=1):
print("[SimpleCameraController] Attaching Camera Handle for adding Disturbance")
self.running = True
self.scale = scale
self.state_ptr = state_ptr
self.camera = cv2.VideoCapture(0)
(_, self.frame) = self.camera.read()
h, w = self.frame.shape[:2]
self.frame = cv2.resize(self.frame, (w//2, h//2))
# w = 320, h = 240
self.ih, self.iw = self.frame.shape[:2]
self.dead_radius = 60//2
self.kernelopen = np.ones((5,5))
self.kernelclose = np.ones((10,10))
# hsv value for the object of interest
self.low = np.array([100, 130, 0])
self.high = np.array([120, 255, 255])
self.camera_handle = threading.Thread(target=self.run)
self.camera_handle.start()
# convert xy to polar coordinates
def xy2pol(self, x,y):
dis = np.sqrt(x**2 + y**2)
angle = np.arctan2(y, x)*180/np.pi
return dis, angle
# get frame and apply a morphological operation
def get_morph_frame(self):
(_, frame) = self.camera.read()
frame = cv2.resize(frame, (self.iw, self.ih))
self.frame = cv2.flip(frame, 1)
hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, self.low, self.high)
mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, self.kernelopen)
mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, self.kernelclose)
return mask
# get polar coordinates for a contour having the max area
def get_max_cont_polar(self, conts):
c = max(conts, key=cv2.contourArea)
x,y,w,h = cv2.boundingRect(c)
cx, cy = x+w//2, y+h//2
cv2.rectangle(self.frame,(x,y),(x+w,y+h), (0,255,0), 2)
cv2.circle(self.frame, (cx, cy), 5, (0, 0, 255), 2)
cx = cx - self.iw//2
cy = self.ih//2 - cy
dis, angle = self.xy2pol(cx, cy)
return dis, angle
# main thread function
def run(self):
while self.running:
temp_frame = self.get_morph_frame()
conts = cv2.findContours(temp_frame.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
conts = conts[0] if len(conts) == 2 else conts[1]
if len(conts) != 0:
dis, angle = self.get_max_cont_polar(conts)
if (dis > self.dead_radius) and (-45 <= angle < 45):
# print("Right")
self.state_ptr[1] -= self.scale
elif (dis > self.dead_radius) and (45 <= angle < 90+45):
# print("Up")
self.state_ptr[2] -= self.scale
elif (dis > self.dead_radius) and (angle >= 90+45 or angle < -180+45):
# print("Left")
self.state_ptr[1] += self.scale
elif (dis > self.dead_radius) and (-180+45 <= angle < -45):
# print("down")
self.state_ptr[2] += self.scale
cv2.circle(self.frame, (self.iw//2, self.ih//2), self.dead_radius, (255, 0, 0), 2)
def close(self):
if self.running:
self.running = False
self.camera_handle.join()
self.camera.release()
cv2.destroyAllWindows()
print("[SimpleCameraController] Camera Handle Closed...")
class HandGestureCameraController:
def __init__(self, scale=1):
print("[HandGestureCameraController] Attaching Camera Handle for position control")
self.running = True
self.scale = scale
self.x_dot = 0.
self.y_dot = 0.
self.z_dot = 0.
self.yaw_rate = 0.
self.camera = cv2.VideoCapture(0)
(_, self.frame) = self.camera.read()
h, w = self.frame.shape[:2]
self.frame = cv2.resize(self.frame, (w//2, h//2))
# w = 320, h = 240
self.ih, self.iw = self.frame.shape[:2]
filt_size = 5
self.kernelopen = | np.ones((filt_size,filt_size)) | numpy.ones |
# 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]) | numpy.array |
import pickle
import json
from collections import OrderedDict
from math import log
from sklearn.metrics.pairwise import cosine_similarity
from numpy.linalg import norm
from datasets import DATASET
import datetime
import os.path
import numpy as np
class TFIDFVectorizer():
def __init__(self, k=1.5, b=0.75):
self.k = k
self.b = b
def tf(self,word,doc, doc_list):
all_num=sum([doc[key] for key in doc])
avg = 0
for vb in doc_list:
avg += sum([vb[key] for key in vb])
avg = avg/len(doc_list)
return (doc[word]*(self.k + 1))/(doc[word] + self.k*(1 - self.b + self.b*all_num/avg))
def idf(self, word,doc_list):
all_num=len(doc_list)
word_count=0
for doc in doc_list:
if word in doc:
word_count+=1
return log((all_num+1)/(word_count+0.5))
def tfidf(self, word,doc,doc_list):
score = self.tf(word,doc, doc_list)*self.idf(word,doc_list)
return score
def compute_tfidf_summary(self, bug_reports):
vocab = []
docs = []
for report in bug_reports.values():
doc = {}
for word in report.summary['unstemmed']:
if word not in vocab:
vocab.append(word)
if word in doc.keys():
doc[word] += 1
else:
doc[word] = 1
for word in report.description['unstemmed']:
if word not in vocab:
vocab.append(word)
if word in doc.keys():
doc[word] += 1
else:
doc[word] = 1
docs.append(doc)
x_tfidf = []
for doc in docs:
for word in doc:
doc[word] = self.tfidf(word,doc,docs)
row = []
for f in vocab:
if f in doc.keys():
row.append(doc[word])
else:
row.append(0)
x_tfidf.append(row)
# should save sparse matrix
return x_tfidf
def compute_similarity(self, x_tfidf, y_tfidf):
"""
compute similarity
"""
n = len(x_tfidf)
size = len(x_tfidf[n-1])
x_tfidf = np.asarray(x_tfidf)
x_similarity = np.empty((n, n), dtype=object)
for i in range(n):
for j in range(n):
x_similarity[i][j] = cosine_similarity(x_tfidf[i].reshape(1,size), y_tfidf[j].reshape(1,size))[0][0]
return x_similarity
def similar_report_scores(src_files, bug_reports):
# duyệt từng bug
tf = TFIDFVectorizer()
x_tfidf = tf.compute_tfidf_summary(bug_reports)
n = len(x_tfidf)
size = len(x_tfidf[n-1])
x_tfidf = np.asarray(x_tfidf)
similarity_report_scores = []
for r1, report in enumerate(bug_reports.values()):
print(r1)
scores = []
input_bug_report = int(report.opendate)
# x là tập B
x = []
for rep in bug_reports.values():
fixed_date_bug = int(rep.fixdate)
if (input_bug_report > fixed_date_bug):
x.append(rep)
# duyệt từng file
for src in src_files.values():
if(len(x) != 0):
simi_score = 0
# duyệt b trong B
for i, relevant_commit in enumerate(x):
files = [r.split('.')[-2]
for r in relevant_commit.fixed_files]
# duyệt từng file f trong b để tìm đc file tương ứng
for f in files:
f = f.split('\\')[-1]
exact_file_name = src.exact_file_name.split(' ')[-1]
if(exact_file_name == f):
# print(relevant_commit.summary['unstemmed'])
# print(report.summary['unstemmed'])
# tc = (input_bug_report - datetime.datetime.strptime(
# relevant_commit.fixdate, '%Y-%m-%d %H:%M:%S').timestamp()) / 60/60/24
# tc = (input_bug_report - int(relevant_commit.fixdate)) / 60 / 60 / 24
simi_score += cosine_similarity(x_tfidf[r1].reshape(1,size), x_tfidf[i].reshape(1,size))[0][0]
scores.append(simi_score)
else:
scores.append(0)
similarity_report_scores.append(scores)
return similarity_report_scores
def main():
# custom max rank = 10 and add set C
with open('../preprocess_data/preprocessed_src.pickle', 'rb') as file:
src_files = pickle.load(file)
with open('../preprocess_data/preprocessed_reports.pickle', 'rb') as file:
bug_reports = pickle.load(file)
scores = similar_report_scores(src_files, bug_reports)
print(len(scores))
print(len(scores[0]))
max_score = | np.max(scores) | numpy.max |
from __future__ import print_function, division
import matplotlib
#matplotlib.use('Agg')
import numpy as np
import scipy as sp
from operator import truediv
import math, time
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from itertools import groupby
import sisl as si
from numbers import Integral
# I don't know why, but the lines below were
# fucking up my routine "makeTB_FrameOutside", on the "contruct" command
#try:
# from itertools import izip as zip
#except:
# pass
def dagger(M):
return np.conjugate(np.transpose(M))
def displaySparse(m, filename, dpi=300):
if not isinstance(m, sp.sparse.coo_matrix):
m = sp.sparse.coo_matrix(m)
fig = plt.figure()
ax = fig.add_subplot(111, axisbg='black')
ax.plot(m.col, m.row, 's', color='white', ms=10)
ax.set_xlim(0, m.shape[1])
ax.set_ylim(0, m.shape[0])
ax.set_aspect('equal')
for spine in ax.spines.values():
spine.set_visible(False)
ax.invert_yaxis()
ax.set_aspect('equal')
ax.set_xticks([])
ax.set_yticks([])
plt.savefig(filename, facecolor='black', edgecolor='black', dpi=dpi)
return ax
def get_potential(TSHS, iio, atoms):
"""
iio: index (0-based) of orbital in basis set (i.e., pz in SZP: iio = 2)
"""
orbs = TSHS.a2o(atoms)+iio
on = TSHS.Hk(dtype=np.float64, format='array')[orbs, orbs]
return on
def check_Dirac(ts, mp, displacement=[0,0,0]):
mp = si.MonkhorstPack(ts, mp, displacement=displacement)
print('Check that Dirac is in here: ')
print(mp.k)
print('Check that this is in *.KP file : {}'.format(mp.tocartesian([0., 1./3, 0]) * si.unit.siesta.unit_convert('Bohr', 'Ang')))
i_dirac = (np.logical_and(mp.k[:,1] == 1./3, mp.k[:,0] == 0.)).nonzero()[0]
if len(i_dirac) != 1:
print('Dirac point is not in the grid')
exit(1)
else:
print('Dirac point is at kindex: {}'.format(i_dirac[0]))
def get_Dirac(hs, mp, displacement=[0,0,0]):
#check_Dirac(hs.geom, mp, displacement)
ens_dirac = hs.eigh(k=[0., 1./3, 0])
i_dirac = hs.na * 2 - 1
return np.average(ens_dirac[i_dirac:i_dirac+2])
def plot_PotDiff(TSHS, TSHS_0, ia, axis, iio, o_dev, o_inner): # include option for frame!
on, yy, atoms = get_potential(TSHS, ia, axis, iio)
on0 = get_potential(TSHS_0, ia, axis, iio)[0]
on0 = np.array([np.mean(on0)]*len(on))
# Check
print('y (Ang)\t\tPot (eV)\tPot0 (eV)\tPot-Pot0 (eV)')
a_dev = TSHS.o2a(o_dev, unique=True)
a_inner = TSHS.o2a(o_inner, unique=True)
for iia, y, o, o0 in zip(atoms, yy, on, on0):
if iia in a_inner:
print('{:7.4f}\t\t{:7.4f}\t\t{:7.4f}\t\t{:7.4f}\t\t(inner)'.format(y,o,o0,o-o0))
else:
print('{:7.4f}\t\t{:7.4f}\t\t{:7.4f}\t\t{:7.4f}'.format(y,o,o0,o-o0))
# Subtract pristine potential
PotDiff = on-on0
# Write to file
with open('PotDiff.dat', 'w') as pf:
for yc, pd in zip(yy, PotDiff):
pf.write('{}\t\t{}\n'.format(yc, pd))
# Plot
figure()
plot(yy, PotDiff, 'b')
md, Md = np.amin(TSHS.xyz[a_dev, axis]), np.amax(TSHS.xyz[a_dev, axis])
axvline(md, color='k', linestyle='dashed', linewidth=2)
axvline(Md, color='k', linestyle='dashed', linewidth=2)
tmp_dev = TSHS.geom.sub(a_dev); tmp_inner = tmp_dev.sub(a_inner)
mi, Mi = np.amin(tmp_inner.xyz[a_inner, axis]), np.amax(tmp_inner.xyz[a_inner, axis])
axvspan(mi, Mi, alpha=0.3, facecolor='blue', edgecolor='none')
ylabel(r'$H_{p_z}-H^0_{p_z}\, (e{\rm V})$', fontsize=20)
xlabel(r'$y\, (\AA)$', fontsize=20)
xlim(0, TSHS.cell[axis, axis])
#xlim(TSHS.center(what='cell')[1], TSHS.cell[1,1])
legend(loc=0); savefig('PotDiff.pdf', bbox_inches='tight')
def get_potential_profile(TSHS, ia, axis, iio):
"""
ia: atom crossed by the line
axis: direction of the line
iio: index (0-based) of orbital in basis set (i.e., pz in SZP: iio = 2)
"""
# Find atoms in line passing by center of
xyz0, xyz = TSHS.xyz[ia, axis%1], TSHS.xyz[:, axis%1]
atoms = np.where(np.logical_and(xyz0-1.43 < xyz, xyz < xyz0+1.43))[0]
v = TSHS.geom.copy(); v.atom[atoms] = si.Atom(8, R=[1.43]); v.write('checkPot.xyz')
orbs = TSHS.a2o(atoms)+iio
on = TSHS.Hk(dtype=np.float64, format='array')[orbs, orbs]
ylist = TSHS.xyz[atoms, axis]
idxs = np.argsort(ylist)
on, ylist = on[idxs], ylist[idxs]
return on, ylist, atoms
def xyz2polar(tbt, origin=0):
na = tbt.na
# radii from origin
if isinstance(origin, Integral):
origin = tbt.xyz[origin]
_, r = tbt.geom.close_sc(origin, R=np.inf, ret_rij=True)
# angles from origin
transl = tbt.geom.translate(-origin)
y = transl.xyz[:,1]
i_ypos = np.where(y >= 0)[0]
i_yneg = np.setdiff1d(np.arange(na), i_ypos)
t = np.zeros(na)
t[i_ypos] = transl.angle(i_ypos, dir=(1., 0, 0), rad=True)
t[i_yneg] = transl.angle(i_yneg, dir=(-1., 0, 0), rad=True) +np.pi
return r, t
def radial_T_from_bc(tbt, elec, E=None, kavg=True,
origin=0, thetamin=0., thetamax=2*np.pi, ntheta=360,
Rmin=5., Rmax=999999999, dr=40.,
input=None, save='radial_T_from_bc.txt', saveinput='rt.txt'):
if E:
Eidx = tbt.Eindex(E)
en = tbt.E[Eidx]
else:
en = tbt.E[0]
print('Using E = {} eV'.format(en))
na = tbt.na
if isinstance(origin, Integral):
origin = tbt.xyz[origin]
# (x, y) ----> (r, t)
if input:
r, t = np.loadtxt(input, delimiter='\t', usecols=(1, 2), unpack=True, skiprows=1)
else:
r, t = xyz2polar(tbt, origin=origin)
f = open(saveinput, 'w')
f.write('ia\tr (Angstrom)\tangle (radians; center {})\n'.format(origin))
for ia, rr, tt in zip(np.arange(na), r, t):
f.write('{}\t{}\t{}\n'.format(ia, rr, tt))
f.close()
print('(x,y) ---> (r,t): DONE')
# theta bins
thetas = np.linspace(thetamin, thetamax, ntheta, endpoint=False)
dtheta = thetas[1]-thetas[0]
print(len(thetas), dtheta, thetas)
# Digitize t into thetas
inds = np.digitize(t, thetas) -1 # First bin is associated to 0.0 rad
print('Digitize theta: DONE')
# radii[i] is the radius of the interface between 2 crowns centered at the position of the tip
newRmax = np.amin(np.absolute(np.array([origin[0], origin[1],
(origin-tbt.cell[0]-tbt.cell[1])[0], (origin-tbt.cell[0]-tbt.cell[1])[1]])))
radii = np.arange(np.amax([Rmin, dr]), np.amin([Rmax, newRmax])+2*dr, dr)
nradii = len(radii)
print(nradii, dr, radii)
# indices of atom within the various shells
# atoms in list ishell[i] belong to [radii[i], radii[i+1]]
ishell = tbt.geom.close_sc(origin, R=radii, idx=tbt.a_dev)
print('Close: DONE')
# Read bond-current
bc = tbt.bond_current(0, en, kavg=kavg, only='all', uc=True)
print('bc: DONE')
Tavg = np.zeros(ntheta*nradii)
thetas_toplot = Tavg.copy()
radii_toplot = Tavg.copy()
j=0
for id in np.arange(ntheta): # Loop over unique angles
print(' Doing theta #{} of {} ({} rad)'.format(id+1, ntheta, thetas[id]))
idx_intheta = np.where(inds == id)[0] # find indices of atoms whose t is in sector theta
for id_r in np.arange(1,nradii-1): # Loop over unique radii
print(' Doing radius #{} of {} ({} Ang)'.format(id_r, nradii, radii[id_r]))
idx_1_indr = ishell[id_r] # Indices of atoms within internal shell
mask = np.in1d(idx_1_indr, idx_intheta)
idx_1 = idx_1_indr[mask] # Indices of atoms in internal shell AND sector theta
idx_2 = ishell[id_r+1] # # Indices of atoms within external shell
Tavg[j] = bc[idx_1.reshape(-1, 1), idx_2.reshape(1, -1)].sum()
thetas_toplot[j] = thetas[id]
radii_toplot[j] = radii[id_r]
#print(' ({} Ang, {} rad) --> {}'.format(radii_toplot[j], thetas_toplot[j], Tavg[j]))
j+=1
# Write
f = open(save, 'w')
f.write('center {}\n'.format(origin))
f.write('radius (Ang), \t theta (rad), \tT from radial bond current\n')
for rr, theta, ttt in zip(radii_toplot, thetas_toplot, Tavg):
f.write('{}\t{}\t{}\n'.format(rr, theta, ttt))
f.close()
return radii_toplot, thetas_toplot, Tavg
def atom_current_radial(tbt, elec, E, kavg=True, activity=True,
origin=0, thetamin=0., thetamax=2*np.pi, ntheta=360,
Rmin=5., Rmax=999999999, dr=40.,
input=None, save='atom_current_radial.txt', saveinput='ac_input.txt'):
if E:
Eidx = tbt.Eindex(E)
en = tbt.E[Eidx]
else:
en = tbt.E[0]
print('Using E = {} eV'.format(en))
na = tbt.na
if isinstance(origin, Integral):
origin = tbt.xyz[origin]
# (x, y) ----> (r, t)
if input:
r, t, ac = np.loadtxt(input, delimiter='\t', usecols=(1, 2, 3), unpack=True, skiprows=1)
else:
r, t = xyz2polar(tbt, origin=origin)
print('start extraction of atom_current...')
ac = tbt.atom_current(elec, E, kavg, activity)
print('...end extraction of atom_current')
f = open(saveinput, 'w')
f.write('ia\tr (Ang)\tangle (rad; center {})\tatom current\n'.format(origin))
for ia, rr, tt, a in zip(np.arange(na), r, t, ac):
f.write('{}\t{}\t{}\t{}\n'.format(ia, rr, tt, a))
f.close()
print('(x,y) ---> (r,t): DONE')
# theta bins
thetas = np.linspace(thetamin, thetamax, ntheta, endpoint=False)
dtheta = thetas[1]-thetas[0]
print('Thetas entries:')
print(len(thetas), dtheta, thetas)
# Digitize t into thetas
inds = np.digitize(t, thetas) -1 # First bin is associated to 0.0 rad
print('Digitize theta: DONE')
# radii[i] is the radius of the interface between 2 crowns centered at the position of the tip
newRmax = np.amin(np.absolute(np.array([origin[0], origin[1],
(origin-tbt.cell[0]-tbt.cell[1])[0], (origin-tbt.cell[0]-tbt.cell[1])[1]])))
radii = np.arange(np.amax([Rmin, dr]), np.amin([Rmax, newRmax])+dr, dr)
nradii = len(radii)
print('Radii entries:')
print(nradii, dr, radii)
# indices of atom within the various shells
# atoms in list ishell[i] belong to [radii[i], radii[i+1]]
#ishell = tbt.geom.close_sc(origin, R=radii, idx=tbt.a_dev)
#print('Close: DONE')
current_r = np.zeros((nradii, ntheta))
for ir, rr in enumerate(radii): # Loop over unique radii
current_t = np.zeros(ntheta)
counts_t = current_t.copy()
inR = np.where(r < rr)[0]
for id, a in zip(inds[inR], ac[inR]):
current_t[id] += a
counts_t[id] += 1
current_r[ir, :] = np.divide(current_t, counts_t)
# Write
np.savetxt(save, np.transpose(np.vstack([thetas, current_r])), delimiter='\t',
newline='\n', comments='', header=', '.join(str(e) for e in radii))
return radii, thetas, current_r
def plot_LDOS(geom, LDOS, figname='figure.png',
vmin=None, vmax=None):
import matplotlib.collections as collections
from matplotlib.colors import LogNorm
from mpl_toolkits.axes_grid1 import make_axes_locatable
x, y = geom.xyz[:,0], geom.xyz[:,1]
fig, ax = plt.subplots()
ax.set_aspect('equal')
vmin, vmax = vmin, vmax
if vmin is None:
vmin = np.min(LDOS)
if vmax is None:
vmax = np.max(LDOS)
colors = LDOS
area = 15
image = ax.scatter(x, y, c=colors, s=area, marker='o', edgecolors='None', cmap='viridis')
image.set_clim(vmin, vmax)
image.set_array(LDOS)
ax.autoscale()
ax.margins(0.1)
plt.xlabel('$x (\AA)$')
plt.ylabel('$y (\AA)$')
plt.gcf()
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
axcb = plt.colorbar(image, cax=cax, format='%1.2f', ticks=[vmin, vmax])
plt.savefig(figname, bbox_inches='tight', transparent=True, dpi=300)
print('Successfully plotted to "{}"'.format(figname))
def CAP(geometry, side, dz_CAP=30, write_xyz=True, zaxis=2):
# Determine orientation
if zaxis == 2:
xaxis, yaxis = 0, 1
elif zaxis == 0:
xaxis, yaxis = 1, 2
elif zaxis == 1:
xaxis, yaxis = 0, 2
# Natural units (see "http://superstringtheory.com/unitsa.html")
hbar = 1
m = 0.511e6 # eV
c = 2.62
print('\nSetting up CAP regions: {}'.format(side))
print('Width of absorbing walls = {} Angstrom'.format(dz_CAP))
Wmax = 100
dH_CAP = si.Hamiltonian(geometry, dtype='complex128')
CAP_list = []
### EDGES
if 'right' in side:
print('Setting at right')
z, y = geometry.xyz[:, xaxis], geometry.xyz[:, yaxis]
z2 = np.max(geometry.xyz[:, xaxis]) + 1.
z1 = z2 - dz_CAP
idx = np.where(np.logical_and(z1 <= z, z < z2))[0]
fz = (4/(c**2)) * ((dz_CAP/(z2-2*z1+z[idx]))**2 + (dz_CAP/(z2-z[idx]))**2 - 2 )
Wz = ((hbar**2)/(2*m)) * (2*np.pi/(dz_CAP/2000))**2 * fz
orbs = dH_CAP.geom.a2o(idx) # if you have just 1 orb per atom, then orb = ia
for orb,wz in zip(orbs, Wz):
dH_CAP[orb, orb] = complex(0, -wz)
CAP_list.append(idx)
#print(list2range_TBTblock(idx))
if 'left' in side:
print('Setting at left')
z, y = geometry.xyz[:, xaxis], geometry.xyz[:, yaxis]
z2 = np.min(geometry.xyz[:, xaxis]) - 1.
z1 = z2 + dz_CAP
idx = np.where(np.logical_and(z2 < z, z <= z1))[0]
fz = (4/(c**2)) * ((dz_CAP/(z2-2*z1+z[idx]))**2 + (dz_CAP/(z2-z[idx]))**2 - 2 )
Wz = ((hbar**2)/(2*m)) * (2*np.pi/(dz_CAP/2000))**2 * fz
orbs = dH_CAP.geom.a2o(idx) # if you have just 1 orb per atom, then orb = ia
for orb,wz in zip(orbs, Wz):
dH_CAP[orb, orb] = complex(0, -wz)
CAP_list.append(idx)
#print(list2range_TBTblock(idx))
if 'top' in side:
print('Setting at top')
z, y = geometry.xyz[:, xaxis], geometry.xyz[:, yaxis]
y2 = np.max(geometry.xyz[:, yaxis]) + 1.
y1 = y2 - dz_CAP
idx = np.where(np.logical_and(y1 <= y, y < y2))[0]
fz = (4/(c**2)) * ( (dz_CAP/(y2-2*y1+y[idx]))**2 + (dz_CAP/(y2-y[idx]))**2 - 2 )
Wz = ((hbar**2)/(2*m)) * (2*np.pi/(dz_CAP/2000))**2 * fz
orbs = dH_CAP.geom.a2o(idx) # if you have just 1 orb per atom, then orb = ia
for orb,wz in zip(orbs, Wz):
dH_CAP[orb, orb] = complex(0, -wz)
CAP_list.append(idx)
#print(list2range_TBTblock(idx))
if 'bottom' in side:
print('Setting at bottom')
z, y = geometry.xyz[:, xaxis], geometry.xyz[:, yaxis]
y2 = np.min(geometry.xyz[:, yaxis]) - 1.
y1 = y2 + dz_CAP
idx = np.where(np.logical_and(y2 < y, y <= y1))[0]
fz = (4/(c**2)) * ( (dz_CAP/(y2-2*y1+y[idx]))**2 + (dz_CAP/(y2-y[idx]))**2 - 2 )
Wz = ((hbar**2)/(2*m)) * (2*np.pi/(dz_CAP/2000))**2 * fz
orbs = dH_CAP.geom.a2o(idx) # if you have just 1 orb per atom, then orb = ia
for orb,wz in zip(orbs, Wz):
dH_CAP[orb, orb] = complex(0, -wz)
CAP_list.append(idx)
#print(list2range_TBTblock(idx))
CAP_list = np.concatenate(CAP_list).ravel().tolist()
if write_xyz:
# visualize CAP regions
visualize = geometry.copy()
visualize.atom[CAP_list] = si.Atom(8, R=[1.44])
visualize.write('CAP.xyz')
return dH_CAP
def read_fullTSHS(HSfilename, geomFDFfilename):
""" Read Hamiltonian and Geometry objects
and update Atoms properties of 'TSHS' from 'FDF' """
if isinstance(HSfilename, str):
HSfile = si.get_sile(HSfilename).read_hamiltonian()
else:
HSfile = HSfilename.copy()
if isinstance(geomFDFfilename, str):
geomFDF = si.get_sile(geomFDFfilename).read_geometry(True)
else:
geomFDF = geomFDFfilename.copy()
# Update species
for ia, (a, afdf) in enumerate(zip(HSfile.atom, geomFDF.atom)):
A = si.Atom(afdf.Z, a.orbital, afdf.mass, afdf.tag)
HSfile.atom[ia] = A
HSfile.reduce()
return HSfile
def T_from_bc(tbt, elec, idx_1, idx_2, E=None, kavg=True, write_xyz=None):
if write_xyz: # visualize regions
visualize = tbt.geom.copy()
visualize.atom[idx_1] = si.Atom(8, R=[1.44])
visualize.atom[idx_2] = si.Atom(9, R=[1.44])
visualize.write('{}.xyz'.format(write_xyz))
if E:
Eidx = tbt.Eindex(E)
energies = np.array([tbt.E[Eidx]])
else:
energies = tbt.E
T = np.zeros(len(energies))
for ie,e in enumerate(energies):
print('Doing E # {} of {} ({} eV)'.format(ie+1, len(energies), e))
bc = tbt.bond_current(elec, e, kavg=kavg, only='all', uc=True)
T[ie] += bc[idx_1.reshape(-1, 1), idx_2.reshape(1, -1)].sum()
return T
def T_from_bc_from_orbital(tbt, elec, o_idx, idx_1, idx_2, E=None,
kavg=True, write_xyz=None):
if write_xyz: # visualize regions
visualize = tbt.geom.copy()
visualize.atom[idx_1] = si.Atom(8, R=[1.44])
visualize.atom[idx_2] = si.Atom(9, R=[1.44])
visualize.write('{}.xyz'.format(write_xyz))
if E:
Eidx = tbt.Eindex(E)
energies = np.array([tbt.E[Eidx]])
else:
energies = tbt.E
T = np.zeros(len(energies))
for ie,e in enumerate(energies):
print('Doing E # {} of {} ({} eV)'.format(ie+1, len(energies), e))
Jij = tbt.orbital_current(elec, e, kavg=kavg)
orbs_1 = tbt.geom.a2o(idx_1) + o_idx
orbs_2 = tbt.geom.a2o(idx_2) + o_idx
T[ie] = Jij[orbs_1.reshape(-1, 1), orbs_2.reshape(1, -1)].sum()
#bc = tbt.bond_current(elec, e, kavg=kavg, only='all', uc=True)
return T
def list2range_TBTblock(lst):
""" Convert a list of elements into a string of ranges
Examples
--------
>>> list2range([2, 4, 5, 6])
2, 4-6
>>> list2range([2, 4, 5, 6, 8, 9])
2, 4-6, 8-9
"""
lst = [el+1 for el in lst]
lst.sort()
# Create positions
pos = [j - i for i, j in enumerate(lst)]
t = 0
rng = ''
for _, els in groupby(pos):
ln = len(list(els))
el = lst[t]
if t > 0:
rng += '\n'
t += ln
if ln == 1:
rng += ' atom ['+str(el)+']'
else:
rng += ' atom [{} -- {}]'.format(el, el+ln-1)
return rng
def create_kpath(Nk):
G2K = (0.4444444444444444 + 0.1111111111111111) ** 0.5
K2M = ((0.6666666666666666 - 0.5) ** 2 + (0.3333333333333333 - 0.5) ** 2) ** 0.5
M2G = (0.25 + 0.25) ** 0.5
Kdist = G2K + K2M + M2G
NG2K = int(Nk / Kdist * G2K)
NK2M = int(Nk / Kdist * K2M)
NM2G = int(Nk / Kdist * M2G)
def from_to(N, f, t):
full = np.empty([N, 3])
ls = np.linspace(0, 1, N, endpoint=False)
for i in range(3):
full[:, i] = f[i] + (t[i] - f[i]) * ls
return full
kG2K = from_to(NG2K, [0.0, 0.0, 0.0], [0.6666666666666666, 0.3333333333333333, 0])
kK2M = from_to(NK2M, [0.6666666666666666, 0.3333333333333333, 0], [0.5, 0.5, 0.0])
kM2G = from_to(NM2G, [0.5, 0.5, 0.0], [0.0, 0.0, 0.0])
xtick = [0, NG2K - 1, NG2K + NK2M - 1, NG2K + NK2M + NM2G - 1]
label = ['G', 'K', 'M', 'G']
return ([xtick, label], np.vstack((kG2K, kK2M, kM2G)))
def plot_bandstructure(H, Nk, ymin=None, ymax=None, style='.',
color='k', label=None):
if type(H) is str:
H = si.get_sile(H).read_hamiltonian()
ticks, k = create_kpath(Nk)
eigs = np.empty([len(k), H.no], np.float64)
for ik, k in enumerate(k):
print('{} / {}'.format(ik+1, Nk), end='\r')
eigs[ik, :] = H.eigh(k=k, eigvals_only=True)
ax = plt.gca()
for n in range(H.no):
print('{} / {}'.format(n+1, H.no), end='\r')
ax.plot(eigs[:, n], style, color=color, label=label if n == 0 else "")
ax.xaxis.set_ticks(ticks[0])
ax.set_xticklabels(ticks[1])
if ymin is None:
ymin = ax.get_ylim()[0]
if ymax is None:
ymax = ax.get_ylim()[1]
ax.set_ylim(ymin, ymax)
for tick in ticks[0]:
ax.plot([tick, tick], [ymin, ymax], 'k')
return ax
def list2colors(inp, colormap, vmin=None, vmax=None):
norm = plt.Normalize(vmin, vmax)
return colormap(norm(inp))
def get_dft_param(tshs, ia, iio, jjo, unique=False, onlynnz=False, idx=None):
""" Read Hamiltonian and get coupling constants between
'iio'-th orbital of atom 'ia' and 'jjo'-th orbital of all other atoms
"""
# Read Hamiltonian
if isinstance(tshs, str):
tshs = si.get_sile(tshs).read_hamiltonian()
HS = tshs.copy()
# Index of iio-th orbital of ia-th atom
io = HS.a2o(ia) + iio
# Coupling elements (all orbitals)
edges = HS.edges(orbital=io, exclude=-1)
# Remove non-jjo connections
# convert to atoms (only unique values)
edges = HS.o2a(edges, unique=True)
if idx is not None:
mask = np.in1d(edges, idx)
edges = edges[mask]
# backconvert to the jjo'th orbital on the connecting atoms
edges = HS.a2o(edges) + jjo
r = HS.orij(io, edges)
couplings = HS[io, edges]
# Sort according to r
idx_sorted = np.argsort(r)
r = r[idx_sorted]
couplings = couplings[idx_sorted, :]
if unique:
idx_uniq, cnt_uniq = np.unique(r.round(decimals=2), return_index=True, return_counts=True)[1:]
r = r[idx_uniq]
couplings = np.array([np.average(couplings[iu:(iu+cu), :], axis=0) for iu,cu in zip(idx_uniq, cnt_uniq)])
return r, couplings
def get_R_hop(tshs, tbt, xyz_tip, pzidx, nn, z_gr=None, return_S=False):
a_dev = tbt.a_dev
tshs_dev = tshs.sub(a_dev)
if z_gr == None:
z_gr = tshs_dev.xyz[0, 2]
C_list = (tshs_dev.xyz[:, 2] == z_gr).nonzero()[0]
# Check that we have selected only carbon atoms
for ia, a in zip(C_list, tshs_dev.atom[C_list]):
if a.Z != 6:
print('WARNING: Some atoms are not carbons in the graphene plane: {} {}'.format(ia, tshs_dev.xyz[ia]))
# Get distances of all C atoms from tip (x,y) position
# (notice that tshs_dev.xyz = tshs.xyz, so we need to use xyz_tip wrt full geom)
#xyz_tip_dev = xyz_tip - tshs_dev.xyz[0]
#xyz_tip_dev[2] = tshs_dev.xyz[0, 2]
_, distance = tshs_dev.geom.close_sc(xyz_tip, R=np.inf, idx=C_list, ret_rij=True)
# Get onsite and couplings for each of the atoms, up to the 3rd nn
hoppings = np.empty((len(distance), nn+1))
if return_S:
overlaps = np.empty((len(distance), nn+1))
for ia in C_list:
# Extracting only pz-projected parameters from TSHS of graphene with tip
_, tmp = get_dft_param(tshs_dev, ia, pzidx, pzidx, unique=True, onlynnz=True, idx=C_list)
for i in range(nn+1):
hoppings[ia, i] = tmp[i][0]
if return_S:
overlaps[ia, i] = tmp[i][1]
# Write sorted data for future usage
isort = np.argsort(distance)
si.io.TableSile('couplings.txt', 'w').write_data(distance[isort], *hoppings[isort].T)
if return_S:
return distance[isort], hoppings[isort].T, overlaps[isort].T
return distance[isort], hoppings[isort].T
def plot_couplings_dft2tb(tshs_pristine, tshs, tbt, xyz_tip, pzidx=2, figname='dH.pdf'):
"""
Compare onsite and couplings of pristine graphene with those of a
dirty graphene system.
Plots both raw data and relative difference.
#
# param0[i][j]
# i=0: on-site
# i=1: 1nn coupling
# i=2: 2nn coupling
# i=3: 3nn coupling
# j=0 : Hamiltonian matrix
# j=1 : Overlap matrix
Example:
import sisl as si
from tbtncTools import plot_couplings_dft2tb
tshs_pristine = si.get_sile('../../pristine_300kpt/GR.TSHS').read_hamiltonian()
tshs = si.get_sile('../../tip_atop_szp/z1.8/GR.TSHS').read_hamiltonian()
tbt = si.get_sile('../../tip_atop_szp/z1.8/siesta.TBT.nc')
xyz_tip = tshs.xyz[-1, :]
plot_couplings_dft2tb(tshs_pristine, tshs, tbt, xyz_tip, pzidx=2, figname='dH.pdf')
"""
# Plot reference lines for well converged pristine graphene system
fig = plt.figure()
ax = fig.add_subplot(111)
# Extracting only pz-projected parameters from TSHS of perfect graphene
_, param0 = get_dft_param(tshs_pristine, 0, pzidx, pzidx, unique=True, onlynnz=True)
# Plot
ax.axhline(y=param0[0][0], label='On-site', c='k', ls='-')
ax.axhline(y=param0[1][0], label='1nn coupling', c='g', ls='-')
ax.axhline(y=param0[2][0], label='2nn coupling', c='r', ls='-')
ax.axhline(y=param0[3][0], label='3nn coupling', c='b', ls='-')
# Plot onsite and couplings for well converged "dirty" graphene system
distance, param = get_R_hop(tshs, tbt, xyz_tip, pzidx)
# Plot
ax.scatter(distance, param[0], label='On-site (tip)', c='k')#, ls='--')
ax.scatter(distance, param[1], label='1nn coupling (tip)', c='g')#, ls='--')
ax.scatter(distance, param[2], label='2nn coupling (tip)', c='r')#, ls='--')
ax.scatter(distance, param[3], label='3nn coupling (tip)', c='b')#, ls='--')
# Mark the distance between the tip (x,y) and the closest distance from outmost frame atoms
rM01 = np.absolute(np.amax(tshs.xyz[:, 0]) - xyz_tip[0])
rM02 = np.absolute(np.amin(tshs.xyz[:, 0]) - xyz_tip[0])
rM11 = np.absolute(np.amax(tshs.xyz[:, 1]) - xyz_tip[1])
rM12 = np.absolute(np.amin(tshs.xyz[:, 1]) - xyz_tip[1])
rM = np.amin([rM01, rM02, rM11, rM12])
ax.axvline(x=rM, c='k', ls='--')
# General plot settings
plt.xlim(0., np.amax(distance))
ax.set_xlabel('$r-r_{\mathrm{tip}}\,(\AA)$')
ax.set_ylabel('E (eV)')
plt.legend(loc=4, fontsize=10, ncol=2)
plt.tight_layout()
for o in fig.findobj():
o.set_clip_on(False)
plt.savefig(figname)
# Plot relative difference
f, axes = plt.subplots(4, sharex=True)
f.subplots_adjust(hspace=0)
axes[0].scatter(distance, param[0]-np.full(len(distance), param0[0][0]),
label='On-site', c='k')
axes[1].scatter(distance, param[1]-np.full(len(distance), param0[1][0]),
label='1nn coupling', c='g')
axes[2].scatter(distance, param[2]-np.full(len(distance), param0[2][0]),
label='2nn coupling', c='r')
axes[3].scatter(distance, param[3]-np.full(len(distance), param0[3][0]),
label='3nn coupling', c='b')
# Mark the distance between the tip (x,y) and the closest distance from outmost frame atoms
for a in axes:
a.axhline(y=0., c='lightgrey', ls='-')
a.axvline(x=rM, c='k', ls='--')
#a.autoscale()
a.set_xlim(0., np.amax(distance))
a.set_ylim(a.get_ylim()[0], 0.)
a.yaxis.set_major_locator(plt.MaxNLocator(3))
# General plot settings
axes[-1].set_xlabel('$r-r_{\mathrm{tip}}\,(\AA)$')
f.text(0.025, 0.5, '$\Delta E $ (eV)', ha="center", va="center", rotation=90)
#for o in f.findobj():
# o.set_clip_on(False)
plt.setp([a.get_xticklabels() for a in f.axes[:-1]], visible=False)
plt.savefig('diff_'+figname)
def sc_xyz_shift(geom, axis):
return (geom.cell[axis,axis] - (np.amax(geom.xyz[:,axis]) - np.amin(geom.xyz[:,axis])))/2
#def Delta(TSHS, HS_TB, shape='Cuboid', z_graphene=None, ext_offset=None, center=None,
def Delta(TSHS, shape='Cuboid', z_graphene=None, ext_offset=None, center=None,
thickness=None, zaxis=2, atoms=None, segment_dir=None):
# z coordinate of graphene plane
if z_graphene is None:
print('\n\nPlease provide a value for z_graphene in Delta routine')
exit(1)
# Center of shape in TSHS
if center is None:
center = TSHS.center(atom=(TSHS.xyz[:,zaxis] == z_graphene).nonzero()[0])
center = np.asarray(center)
# Thickness in Ang
if thickness is None:
thickness = 6. # Ang
#thickness = HS_TB.maxR()+0.01
thickness = np.asarray(thickness, np.float64)
# Cuboid or Ellissoid?
if zaxis == 2:
size = .5*np.diagonal(TSHS.cell) + [0,0,300] # default radius is half the cell size
elif zaxis == 0:
size = .5*np.diagonal(TSHS.cell) + [300,0,0] # default radius is half the cell size
elif zaxis == 1:
size = .5*np.diagonal(TSHS.cell) + [0,300,0] # default radius is half the cell size
if shape == 'Ellipsoid' or shape == 'Sphere':
mkshape = si.shape.Ellipsoid
elif shape == 'Cuboid' or shape == 'Cube':
mkshape = si.shape.Cuboid
# In this case it's the full perimeter so we double
size *= 2
thickness *= 2
if ext_offset is not None:
ext_offset = np.asarray(ext_offset, np.float64).copy()
ext_offset *= 2
elif shape == 'Segment':
mkshape = si.shape.Cuboid
# In this case it's the full perimeter so we double
size *= 2
area_tot = mkshape(size, center=TSHS.center(atom=(TSHS.xyz[:,zaxis] == z_graphene).nonzero()[0]))
size[segment_dir] = thickness
if ext_offset is not None:
ext_offset = np.asarray(ext_offset, np.float64).copy()
else:
print('\n shape = "{}" is not implemented...'.format(shape))
exit(1)
if shape == 'Segment': # ADD COMPLEMENTARY AREA...
# Areas
Delta = mkshape(size, center=center)
# Atoms within Delta and complementary area
a_Delta = Delta.within_index(TSHS.xyz)
if atoms is not None:
a_Delta = a_Delta[np.in1d(a_Delta, atoms)]
# Check
v = TSHS.geom.copy(); v.atom[a_Delta] = si.Atom(8, R=[1.43]); v.write('a_Delta.xyz')
return a_Delta, Delta
else:
# External boundary
area_ext = mkshape(size, center=center)
# Adjust with ext_offset if necessary
if ext_offset is not None:
ext_offset = np.asarray(ext_offset, np.float64)
area_ext = area_ext.expand(-ext_offset)
# Force it to be Cube or Sphere (side = ext_offset) if necessary
if shape == 'Sphere' or shape == 'Cube':
if len(ext_offset.nonzero()[0]) > 1:
print('Offset is in both axes. Please set "shape" to Cuboid or Ellipsoid')
exit(1)
axis = ext_offset.nonzero()[0][0]
print('Offset is non-zero along axis: {}...complementary is {}'.format(axis, int(axis<1)))
new_ext_offset = np.zeros(3); new_ext_offset[int(axis<1)] = ext_offset[axis]
area_ext = area_ext.expand(-new_ext_offset)
#a_ext = area_ext.within_index(TSHS.xyz)
# Internal boundary
area_int = area_ext.expand(-thickness)
# Disjuction composite shape
Delta = area_ext - area_int
# Atoms within Delta and internal boundary
a_Delta = Delta.within_index(TSHS.xyz)
a_int = area_int.within_index(TSHS.xyz)
if atoms is not None:
a_Delta = a_Delta[np.in1d(a_Delta, atoms)]
# Check
v = TSHS.geom.copy(); v.atom[a_Delta] = si.Atom(8, R=[1.43]); v.write('a_Delta.xyz')
return a_Delta, a_int, Delta, area_ext, area_int
def makeTB(TSHS_0, pzidx, nn, WW, LL, elec=None, save=True, return_bands=False):
"""
TSHS_0: tbtncSile object from "pristine graphene" reference calculation
pzidx: index of pz orbitals in the basis set used to create 'TSHS_0'
nn: no. of neighbours to be used in the TB model
W: width of TB geometry (Angstrom) - transverse direction: 0 -
L: length of TB geometry (Angstrom) - transport direction: 1 -
elec: tbtncSile object from electrode calculation
"""
########################## From PERFECT graphene reference TSHS
dR = 0.005
# Check
for a in TSHS_0.atom.atom:
if a.Z != 6:
print('ERROR: cannot build TB model because the provided geometry \
is not a pristine graphene')
exit(1)
# Extracting only pz-projected parameters from TSHS of perfect graphene
r, param = get_dft_param(TSHS_0, 0, pzidx, pzidx, unique=True, onlynnz=True)
print('\nEffective no. of neighbors per atom from TSHS_0: {}'.format(len(r)-1))
print('\nr ({}; Angstrom)\t param ({}; eV):'.format(len(r), len(param)))
for ri, ci in zip(r, param):
print('{:.5f} \t '.format(ri), ci)
def get_graphene_H(radii, param, dR=dR):
# In order to get the correct radii of the orbitals it is
# best to define them explicitly.
# This enables one to "optimize" the number of supercells
# subsequently.
# Define the radii of the orbital to be the maximum
C = si.Atom(6, R=radii[-1] + dR)
# Define graphene
g = si.geom.graphene(radii[1], C, orthogonal=True)
g.optimize_nsc()
# Now create Hamiltonian
H = si.Hamiltonian(g, orthogonal=False)
# Define primitive also for check of bandstructure
g_s = si.geom.graphene(radii[1], C)
g_s.optimize_nsc()
H_s = si.Hamiltonian(g_s, orthogonal=False)
if len(param.shape) == 1:
# Create a new fake parameter
# with overlap elements
new_param = np.zeros([len(param), 2], dtype=np.float64)
new_param[:, 0] = param
new_param[0, 1] = 1. # on-site, everything else, zero
param = new_param
H.construct((radii+dR, param))
H_s.construct((radii+dR, param))
return H, H_s
# Setup the Hamiltonian building block
if nn is 'all':
print('WARNING: you are retaining ALL interactions from DFT model')
H0, H0_s = get_graphene_H(r, param)
else:
print('WARNING: you are retaining only interactions up to {} neighbours'.format(nn))
H0, H0_s = get_graphene_H(r[:nn+1], param[:nn+1])
print('\nBuilding block for TB model:\n', H0)
# Setup TB model
W, L = int(round(WW/H0.cell[0,0])), int(round(LL/H0.cell[1,1]))
# ELECTRODE
if elec is not None:
n_el = int(round(elec.cell[1,1]/H0.cell[1,1]))
else:
n_el = 2
HS_elec = H0.tile(W, 0).tile(n_el, 1)
HS_elec.write('HS_ELEC.nc')
HS_elec.geom.write('HS_ELEC.fdf')
HS_elec.geom.write('HS_ELEC.xyz')
# DEVICE + ELECTRODES (to be written ONLY after selection and rearranging of GF/dSE area)
HS_dev = H0.tile(W, 0).tile(L, 1)
if save:
HS_dev.write('HS_DEV_0.nc')
HS_dev.geom.write('HS_DEV_0.fdf')
HS_dev.geom.write('HS_DEV_0.xyz')
# Check bands with primitive cell
if return_bands:
# Open figure outside and bands will automatically be added to the plot
plot_bandstructure(H0_s, 400, ymin=-3, ymax=3,
style='-', color='k', label='Pristine $p_z$ parameters')
return HS_dev
def makeTB_FrameOutside(tshs, tbt, center, TSHS_0, pzidx, nn, WW, LL,
elec=None, save=True, return_bands=False, z_graphene=None):
"""
tshs: TSHS object from "dirty graphene" calculation
tbt: tbtncSile object from tbtrans calculation with HS: "tshs"
TSHS_0: TSHS object from "pristine graphene" reference calculation
pzidx: index of pz orbitals in the basis set used to create 'TSHS_0'
nn: no. of neighbours to be used in the TB model
WW: width of TB geometry (Angstrom) - transverse direction: 0 -
LL: length of TB geometry (Angstrom) - transport direction: 1 -
TSHS_elec: tbtncSile object from electrode calculation
save: True will store device region netcdf files for usage in tbtrans
"""
########################## From PERFECT graphene reference TSHS
dR = 0.005
# Check that TSHS_0 has only carbon atoms
for a in TSHS_0.atom.atom:
if a.Z != 6:
print('ERROR: cannot build TB model because the provided geometry\n\tis not a pristine graphene')
exit(1)
# Extracting only pz-projected parameters from TSHS of perfect graphene
r, param = get_dft_param(TSHS_0, 0, pzidx, pzidx, unique=True, onlynnz=True)
print('\nEffective no. of neighbors per atom from TSHS_0: {}'.format(len(r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(r), len(param)))
for ri, ci in zip(r, param):
print('{:.5f} \t '.format(ri), ci)
# Setup the Hamiltonian building block
if nn is 'all':
nn = len(r)-1
# The reference values we wish to target (pristine graphene)
ref_r, ref_hop, ref_over = r[:nn+1], param[:nn+1, 0], param[:nn+1, 1]
print('Targeted no. of neighbors per atom from TSHS_0: {}'.format(len(ref_r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(ref_r), len(ref_hop)))
for ri, ci, oi in zip(ref_r, ref_hop, ref_over):
print('{:.5f} \t '.format(ri), ci, oi)
# R and hopping from tshs, center is the coordinates of the tip apex
# This works Only if the frame is the outmost atoms in tbt.a_dev
# Maybe it's better to define a shape here!
if z_graphene is None:
print('\n\nPlease provide a value for z_graphene')
exit(1)
if center is None:
center = tshs.center(atom=(tshs.xyz[:,2] == z_graphene).nonzero()[0])
print('makeTB: you are considering this as center: {}'.format(center))
distances, hop = get_R_hop(tshs, tbt, center, pzidx, nn, z_gr=z_graphene)
hop_atframe = [np.average(hop[i, np.arange(-10, 0)]) for i in range(nn+1)]
# r's to plot
r2plot = np.linspace(0, np.amax(distances), 1000)
f, ax = plt.subplots(nn+1, sharex=True)
for i in range(nn+1):
ax[i].scatter(distances, hop[i, :])
# Plot lines
ax[i].plot([r2plot.min(), r2plot.max()], [ref_hop[i], ref_hop[i]], '--')
ymin = np.amin([ref_hop[i], hop_atframe[i]]) - 0.1
ymax = np.amax([ref_hop[i], hop_atframe[i]]) + 0.1
ax[i].set_ylim(ymin, ymax)
ax[i].set_xlim(r2plot.min(), r2plot.max())
f.savefig('shifting_data.pdf')
plt.close(f)
###### Create device Hamiltonian
bond = ref_r[1] # to make it fit in a smaller unit-cell
C = si.Atom(6, R=ref_r[-1] + dR)
g0 = si.geom.graphene(bond, C, orthogonal=True)
g0.optimize_nsc()
H0 = si.Hamiltonian(g0, orthogonal=False)
print('\nNo. of neighbors per atom: {}'.format(len(ref_r)-1))
print('r ({}; Angstrom)\t Final parameters from frame ({}; eV):'.format(len(ref_r), len(hop_atframe)))
for ri, ci, oi in zip(ref_r, hop_atframe, ref_over):
print('{:.5f} \t '.format(ri), ci, oi)
# Construct TB. onsite is the same as tip tshs, while couplings are the same as pristine
H0.construct((ref_r+dR, zip(hop_atframe, ref_over)), eta=True)
# DEVICE + ELECTRODES geometry
# Width and length of device
W, L = int(round(WW/g0.cell[0,0])), int(round(LL/g0.cell[1,1]))
print('Device is {} x {} supercell of the unit orthogonal cell'.format(W, L))
# (nc files should be written ONLY after selection and rearranging of GF/dSE area)
HS_dev = H0.tile(W, 0).tile(L, 1)
if save:
HS_dev.write('HS_DEV.nc')
HS_dev.geom.write('HS_DEV.fdf')
HS_dev.geom.write('HS_DEV.xyz')
# ELECTRODE
if elec is not None:
n_el = int(round(elec.cell[1,1]/H0.cell[1,1]))
else:
n_el = 2
HS_elec = H0.tile(W, 0).tile(n_el, 1)
HS_elec.write('HS_ELEC.nc')
HS_elec.geom.write('HS_ELEC.fdf')
HS_elec.geom.write('HS_ELEC.xyz')
# Check bands with primitive cell
if return_bands:
g0_s = si.geom.graphene(bond, C)
g0_s.optimize_nsc()
H0_s = si.Hamiltonian(g0_s, orthogonal=False)
H0_s.construct((ref_r+dR, zip(hop_atframe, ref_over)))
# Open figure outside and bands will automatically be added to the plot
plot_bandstructure(H0_s, 400, ymin=-3, ymax=3,
style='--', color='r', label='Pristine w/ tip $p_z$ onsite')
return HS_dev
def interp1d(x, y, y0, y1):
""" Create an interpolation function from x, y.
The resulting function has these properties:
x < x.min():
f(x) = y0
x.min() < x < x.max():
f(x) = y
x.max() < x:
f(x) = y1
"""
return sp.interpolate.interp1d(x, y, bounds_error=False,
fill_value=(y0, y1))
def func_smooth_fermi(x, y, first_x, second_x, y1, delta=8):
""" Return an interpolation function with the following properties:
x < first_x:
f(x) = y(first_x)
first_x < x < second_x:
f(x) = y
second_x < x
f(x) = y1
`delta` determines the amount of the smearing width that is between `first_x` and
`second_x`.
Parameters
----------
x, y : numpy.ndarray
x/y-data points
first_x : float
the point of cut-off for the x-values. In this approximation we assume
the `y` data-points has a plateau in the neighbourhood of `first_x`
second_x : float
above this `x` value all values will be `y1`.
y1 : float
second boundary value
delta : float, optional
amount of smearing parameter in between `first_x` and `second_x` (should not be below 6!).
"""
# First we will find the first flat plateau
# We do this considering values -3 : +3 Ang
if first_x < np.amax(x):
raise ValueError("first_x has to be larger than maximum, interpolation x value")
# First we will find the first flat plateau
# We do this considering values -3 : r_max Ang
idx = (np.amax(x) - x > -3.).nonzero()[0]
y0 = np.average(y[idx])
# We already have the second plateau.
# So all we have to do is calculate the smearing
# to capture the smoothing range
mid_x = (first_x + second_x) / 2
sigma = (second_x - first_x) / delta
if y0 < y1:
sigma = - sigma
b = y0
else:
b = y1
# Now we can create the function
dd = delta / 2. + 1.
## Now calculate function parameters used for interpolation
#x = np.arange(first_x - dd , second_x + dd, 0.01) # 0.01 Ang precision
#y = abs(y1 - y0) / (np.exp((x - mid_x) / sigma) + 1) + b
#return interp1d(x, y, y0, y1)
# Now we can create the function
dd = delta / 2. + 1.
# Now calculate function parameters used for interpolation
xff = np.arange(first_x, second_x + 2 * dd, 0.01) # 0.01 Ang precision
yff = abs(y1 - y0) / (np.exp((x - mid_x) / sigma) + 1) + b
return interp1d(np.append(x, xff), np.append(y, yff), y[0], y1)
def func_smooth_linear(x, y):
return sp.interpolate.interp1d(x, y, kind='cubic', fill_value=(y[0], y[-1]), bounds_error=False)
def func_smooth(x, y, first_x=None, second_x=None, y1=None, delta=8, what='linear'):
if what is None:
what = 'linear'
if what == 'fermi':
return func_smooth_fermi(x, y, first_x, second_x, y1, delta)
elif what == 'linear':
return func_smooth_linear(x, y)
def makeTB_InterpFrame(tshs, tbt, xyz_tip, TSHS_0, pzidx, nn, WW, LL,
elec=None, save=True, return_bands=False, avg=False):
"""
tshs: TSHS object from "dirty graphene" calculation
tbt: tbtncSile object from tbtrans calculation with HS: "tshs"
TSHS_0: TSHS object from "pristine graphene" reference calculation
pzidx: index of pz orbitals in the basis set used to create 'TSHS_0'
nn: no. of neighbours to be used in the TB model
WW: width of TB geometry (Angstrom) - transverse direction: 0 -
LL: length of TB geometry (Angstrom) - transport direction: 1 -
TSHS_elec: tbtncSile object from electrode calculation
save: True will store device region netcdf files for usage in tbtrans
"""
########################## From PERFECT graphene reference TSHS
dR = 0.005
# Check that TSHS_0 has only carbon atoms
for a in TSHS_0.atom.atom:
if a.Z != 6:
print('ERROR: cannot build TB model because the provided geometry\n\tis not a pristine graphene')
exit(1)
# Extracting only pz-projected parameters from TSHS of perfect graphene
r, param = get_dft_param(TSHS_0, 0, pzidx, pzidx, unique=True, onlynnz=True)
print('\nEffective no. of neighbors per atom from TSHS_0: {}'.format(len(r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(r), len(param)))
for ri, ci in zip(r, param):
print('{:.5f} \t '.format(ri), ci)
# Setup the Hamiltonian building block
if nn is 'all':
nn = len(r)-1
# The reference values we wish to target (pristine graphene)
ref_r, ref_hop, ref_over = r[:nn+1], param[:nn+1, 0], param[:nn+1, 1]
print('Targeted no. of neighbors per atom from TSHS_0: {}'.format(len(ref_r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(ref_r), len(ref_hop)))
for ri, ci, oi in zip(ref_r, ref_hop, ref_over):
print('{:.5f} \t '.format(ri), ci, oi)
# Get distance from tip and relative hoppings, sorted
distances, hop = get_R_hop(tshs, tbt, xyz_tip, pzidx, nn)
if avg:
hop_atframe = [np.average(hop[i, np.arange(-10, 0)]) for i in range(nn+1)]
else:
fit = [func_smooth(distances, hop[i, :]) for i in range(nn+1)]
# r's to plot
r2plot = | np.linspace(0, 1.2*distances[-1], 1000) | numpy.linspace |
""" Newton Raphson Power Flow Solution
Author: <NAME>
Date: 06/09/2021
"""
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
class PowerFlow:
""" Class description
database, call the xlsx file that store database system,
"""
def __init__(self, database):
self._database = 'C:\\Users\\Luis\\Documents\\Python Scripts\\SteadyStatePowerSystem\\Database\\' +database # Current directory + database
def get_database(self):
self._bus = pd.read_excel(self._database, 'bus', header= None).to_numpy()
self._line = pd.read_excel(self._database, 'line', header= None).to_numpy()
def compute_ybus(self):
self.nbus, self.nline = len(self._bus), len(self._line)
z = self._line[:,2] +self._line[:,3]*1j #impedance line, R+jX
y, y_bus = 1/z, self._bus[:,7] + self._bus[:,8]*1j # Admitance line, bus
a, b = self._line[:,5 ], self._line[:,4]*1j # turns ratio, capacitive susceptance
ssend, eend = self._line[:,0].astype(int), self._line[:,1].astype(int)
self.Ybus = np.zeros((self.nbus,self.nbus), dtype= complex)
for i in range(self.nline): #Off diagonal elements
if a[i] != 0: #with transformation ratio
self.Ybus[ssend[i]-1, eend[i]-1] += -y[i]/a[i]
self.Ybus[eend[i]-1, ssend[i]-1] = self.Ybus[ssend[i]-1, eend[i]-1]
else:
self.Ybus[ssend[i]-1, eend[i]-1] += -y[i]
self.Ybus[eend[i]-1, ssend[i]-1] = self.Ybus[ssend[i]-1, eend[i]-1]
for j in range(self.nbus): # Add shunt admitances to diagonal elements of Ybus
self.Ybus[j,j] += y_bus[j]
for k in range(self.nline):
if ssend[k] == j+1 or eend[k] == j+1:
if a[j] != 0 and a[j] != 1:
if ssend[k] == j+1:
self.Ybus[j,j] += y[k]/a[k] + b[k]/2 \
+ (1/a[k])*(1/a[k]-1)*y[k]
elif eend[k] == j+1:
self.Ybus[j,j] += y[k]/a[k] + b[k]/2 \
+ (1-1/a[k])*y[k]
else:
self.Ybus[j,j] += y[k]/a[k] + b[k]/2
return self.Ybus
def compute_pq(self, v, ang):
P, Q = np.zeros(self.nbus), np.zeros(self.nbus)
dP, dQ = np.zeros(self.nbus), np.zeros(self.nbus)
for i in range(self.nbus):
P[i] = v[i]*sum(v*np.abs(self.Ybus[:,i])*np.cos(np.angle(self.Ybus[:,i])-ang[i]+ang))
Q[i] = -v[i]*sum(v*np.abs(self.Ybus[:,i])*np.sin(np.angle(self.Ybus[:,i])-ang[i]+ang))
if self._bus[i, 9] == 2:
dP[i] = self._bus[i,3] - self._bus[i,5] - P[i]
elif self._bus[i, 9] == 3:
dP[i] = self._bus[i,3] - self._bus[i,5] - P[i]
dQ[i] = self._bus[i,4] - self._bus[i,6] - Q[i]
return P, Q, dP, dQ
def jacobian(self, v, ang, P, Q):
""" comput Jacobian with the current voltajes and angles
------------ Input -----------------
v: current voltaje
ang: angle of nodes
P: real power of nodes
Q: reactive power at each nodes
------------ Output ----------------
J: jacobian with dimensions (nbus + nload -1)x(nbus + nload -1)
"""
nload = np.count_nonzero(self._bus[:,9]==3)
j1, j2 = np.zeros((self.nbus-1,self.nbus-1)), np.zeros((self.nbus-1, nload))
j3, j4 = | np.zeros((nload,self.nbus-1)) | numpy.zeros |
# <NAME>
# 3/18/2019
# General object to run empirical sr actflow process
# For group-level/cross-subject analyses
import numpy as np
import os
import multiprocessing as mp
import scipy.stats as stats
import nibabel as nib
import os
os.environ['OMP_NUM_THREADS'] = str(1)
import sklearn
from scipy import signal
import h5py
import sys
sys.path.append('glmScripts/')
import glmScripts.taskGLMPipeline_v2 as tgp
import sys
import pandas as pd
import pathlib
import calculateFC as fc
import tools
# Using final partition
networkdef = np.loadtxt('/home/ti61/f_mc1689_1/NetworkDiversity/data/network_partition.txt')
networkorder = np.asarray(sorted(range(len(networkdef)), key=lambda k: networkdef[k]))
networkorder.shape = (len(networkorder),1)
# network mappings for final partition set
networkmappings = {'fpn':7, 'vis1':1, 'vis2':2, 'smn':3, 'aud':8, 'lan':6, 'dan':5, 'con':4, 'dmn':9,
'pmulti':10, 'none1':11, 'none2':12}
networks = networkmappings.keys()
## General parameters/variables
nParcels = 360
class Model():
"""
Class to perform empirical actflow for a given subject (stimulus-to-response)
"""
def __init__(self,projectdir='/home/ti61/f_mc1689_1/SRActFlow/',ruletype='12',n_hiddenregions=10,randomize=False,scratchfcdir=None):
"""
instantiate:
indices for condition types
indices for specific condition instances
betas
"""
#### Set up basic model parameters
self.projectdir = projectdir
# Excluding 084
self.subjNums = ['013','014','016','017','018','021','023','024','026','027','028','030','031','032','033',
'034','035','037','038','039','040','041','042','043','045','046','047','048','049','050',
'053','055','056','057','058','062','063','066','067','068','069','070','072','074','075',
'076','077','081','085','086','087','088','090','092','093','094','095','097','098','099',
'101','102','103','104','105','106','108','109','110','111','112','114','115','117','119',
'120','121','122','123','124','125','126','127','128','129','130','131','132','134','135',
'136','137','138','139','140','141']
self.inputtypes = ['RED','VERTICAL','CONSTANT','HIGH']
self.ruletype = ruletype
#### Load in atlas
glasserfile2 = projectdir + 'data/Q1-Q6_RelatedParcellation210.LR.CorticalAreas_dil_Colors.32k_fs_RL.dlabel.nii'
glasser2 = nib.load(glasserfile2).get_data()
glasser2 = np.squeeze(glasser2)
self.glasser2 = glasser2
####
# Define hidden units
if n_hiddenregions!=None:
#######################################
#### Select hidden layer regions
hiddendir = projectdir + 'data/results/MAIN/RSA/'
hiddenregions = np.loadtxt(hiddendir + 'RSA_Similarity_SortedRegions2.txt',delimiter=',')
#######################################
#### Output directory
if randomize:
print("Constructing model with", n_hiddenregions, "randomly selected hidden regions")
fcdir = scratchfcdir
#### Necessary to optimize amarel
pathlib.Path(fcdir).mkdir(parents=True, exist_ok=True) # Make sure directory exists
hiddenregions = np.random.choice(hiddenregions,size=n_hiddenregions,replace=False)
else:
print("Constructing model with", n_hiddenregions, "hidden regions")
fcdir = projectdir + 'data/results/MAIN/fc/LayerToLayerFC_' + str(n_hiddenregions) + 'Hidden/'
pathlib.Path(fcdir).mkdir(parents=True, exist_ok=True) # Make sure directory exists
# Select hidden layer
if n_hiddenregions < 0:
hiddenregions = hiddenregions[n_hiddenregions:]
else:
hiddenregions = hiddenregions[:n_hiddenregions]
## Set object attributes
self.n_hiddenregions = n_hiddenregions
self.hiddenregions = np.squeeze(hiddenregions)
self.fcdir = fcdir
self.hidden = True # Set this variable to true - indicates to run sr simulations with a hidden layer
#### identify hidden region vertex indices
hidden_ind = []
for roi in hiddenregions:
hidden_ind.extend(np.where(self.glasser2==roi+1)[0])
self.hidden_ind = hidden_ind
else:
print("Constructing model with NO hidden layers")
fcdir = projectdir + 'data/results/MAIN/fc/LayerToLayerFC_NoHidden/'
pathlib.Path(fcdir).mkdir(parents=True, exist_ok=True) # Make sure directory exists
self.hidden = False # Set this variable to true - indicates to run sr simulations with a hidden layer
self.fcdir = fcdir
self.hiddenregions = None
self.n_hiddenregions = n_hiddenregions
####
# Define task rule (input) layer
ruledir = self.projectdir + 'data/results/MAIN/RuleDecoding/'
if ruletype=='12':
rule_regions = np.loadtxt(ruledir + self.ruletype + 'Rule_Regions.csv',delimiter=',')
elif ruletype=='fpn':
rule_regions = []
rule_regions.extend(np.where(networkdef==networkmappings['fpn'])[0])
rule_regions = np.asarray(rule_regions)
elif ruletype=='nounimodal':
allrule_regions = np.loadtxt(ruledir + '12Rule_Regions.csv',delimiter=',')
unimodal_nets = ['vis1','aud']
unimodal_regions = []
for net in unimodal_nets:
unimodal_regions.extend(np.where(networkdef==networkmappings[net])[0])
# only include regions that are in allrule_regions but also NOT in unimodal_regions
rule_regions = []
for roi in allrule_regions:
if roi in unimodal_regions:
continue
else:
rule_regions.append(roi)
rule_regions = np.asarray(rule_regions)
rule_ind = []
for roi in rule_regions:
rule_ind.extend(np.where(self.glasser2==roi+1)[0])
self.rule_ind = rule_ind
####
# Define motor regions
# Set indices for layer-by-layer vertices
targetdir = projectdir + 'data/results/MAIN/MotorResponseDecoding/'
motor_resp_regions_LH = np.loadtxt(targetdir + 'MotorResponseRegions_LH.csv',delimiter=',')
motor_resp_regions_RH = np.loadtxt(targetdir + 'MotorResponseRegions_RH.csv',delimiter=',')
targetROIs = np.hstack((motor_resp_regions_LH,motor_resp_regions_RH))
# Define all motor_ind
motor_ind = []
for roi in targetROIs:
roi_ind = np.where(glasser2==roi+1)[0]
motor_ind.extend(roi_ind)
motor_ind = np.asarray(motor_ind).copy()
self.motor_ind = motor_ind
#### override -- only pick the motor parcel with the greatest response decoding
motor_ind_lh = []
for roi in motor_resp_regions_LH:
# only include left hand responses in the right hemisphere
if roi>=180:
roi_ind = np.where(glasser2==roi+1)[0]
motor_ind_lh.extend(roi_ind)
motor_ind_rh = []
for roi in motor_resp_regions_RH:
# only include left hand responses in the right hemisphere
if roi<180:
roi_ind = np.where(glasser2==roi+1)[0]
motor_ind_rh.extend(roi_ind)
#
motor_ind_rh = np.asarray(motor_ind_rh).copy()
motor_ind_lh = np.asarray(motor_ind_lh).copy()
self.motor_ind_rh = motor_ind_rh
self.motor_ind_lh = motor_ind_lh
#### Load model task set
filename= projectdir + 'data/results/MAIN/EmpiricalSRActFlow_AllTrialKeys_15stims_v3.csv' # Great
self.trial_metadata = pd.read_csv(filename)
def computeGroupFC(self,n_components=500,nproc='max'):
"""
Function that wraps _computeSubjFC() to compute FC for all subjs, and computes averaged groupFC
"""
if nproc=='max':
nproc=mp.cpu_count()
inputs = []
for subj in self.subjNums:
inputs.append((subj,n_components))
pool = mp.Pool(processes=nproc)
if self.hidden:
pool.starmap_async(self._computeSubjFC,inputs)
else:
pool.starmap_async(self._computeSubjFC_NoHidden,inputs)
pool.close()
pool.join()
#### Compute group FC
for inputtype in self.inputtypes:
if self.hidden:
fc.computeGroupFC(inputtype,self.fcdir)
else:
fc.computeGroupFC_NoHidden(inputtype,self.fcdir)
if self.hidden:
fc.computeGroupFC(self.ruletype,self.fcdir)
else:
fc.computeGroupFC_NoHidden(self.ruletype,self.fcdir)
def loadRealMotorResponseActivations(self,vertexmasks=True):
#### Load motor response activations localized in output vertices only (for faster loading)
if vertexmasks:
print('Load real motor responses in output vertices')
self.data_task_rh, self.data_task_lh = tools.loadMotorResponsesOutputMask()
else:
print('Load real motor responses in output parcels -- inefficient since need to load all vertices first')
data_task_rh = []
data_task_lh = []
for subj in self.subjNums:
tmp_rh = tools.loadMotorResponses(subj,hand='Right')
tmp_lh = tools.loadMotorResponses(subj,hand='Left')
data_task_rh.append(tmp_rh[self.motor_ind_rh,:].copy().T)
data_task_lh.append(tmp_lh[self.motor_ind_lh,:].copy().T)
self.data_task_rh = np.asarray(data_task_rh).T
self.data_task_lh = np.asarray(data_task_lh).T
def loadModelFC(self):
if self.hidden:
print('Load Model FC weights')
fcdir = self.fcdir
self.fc_input2hidden = {}
self.eig_input2hidden = {}
for inputtype in ['VERTICAL','RED','HIGH','CONSTANT']:
self.fc_input2hidden[inputtype], self.eig_input2hidden[inputtype] = tools.loadGroupActFlowFC(inputtype,fcdir)
# Load rule to hidden
self.fc_12rule2hidden, self.eig_12rule2hidden = tools.loadGroupActFlowFC(self.ruletype,fcdir)
# Load hidden to motor resp mappings
self.fc_hidden2motorresp, self.eig_hidden2motorresp = tools.loadGroupActFlowFC('hidden2out',fcdir)
else:
print('Load Model FC weights -- No hidden layer')
fcdir = self.fcdir
self.fc_input2output = {}
self.eig_input2output = {}
for inputtype in ['VERTICAL','RED','HIGH','CONSTANT']:
self.fc_input2output[inputtype], self.eig_input2output[inputtype] = tools.loadGroupActFlowFC_NoHidden(inputtype,fcdir)
# Load rule to hidden
self.fc_12rule2output, self.eig_12rule2output = tools.loadGroupActFlowFC_NoHidden('12',fcdir)
def simulateGroupActFlow(self,thresh=0,nproc='max',vertexmasks=True):
"""
Simulate group level actflow (all subject simulations)
"""
if nproc=='max':
nproc=mp.cpu_count()
inputs = []
for subj in self.subjNums:
inputs.append((subj,thresh))
if nproc == 1:
results = []
for input1 in inputs:
results.append(self._simulateSubjActFlow(input1[0],input1[1]))
else:
pool = mp.Pool(processes=nproc)
results = pool.starmap_async(self._simulateSubjActFlow,inputs).get()
pool.close()
pool.join()
actflow_predictions = np.zeros((len(self.subjNums),len(self.motor_ind),4))
#actflow_predictions_noReLU = np.zeros((len(self.subjNums),len(self.motor_ind),4))
scount = 0
for result in results:
# actflow_predictions[scount,:,:] = result[0]
# actflow_predictions_noReLU[scount,:,:] = result[1]
actflow_predictions[scount,:,:] = result
scount += 1
## Reformat to fit shape of actual data array
actflow_rh = np.zeros((len(self.glasser2),2,len(self.subjNums)))
actflow_lh = np.zeros((len(self.glasser2),2,len(self.subjNums)))
for scount in range(len(self.subjNums)):
# RMID
actflow_rh[self.motor_ind,0,scount] = actflow_predictions[scount,:,2]
# RIND
actflow_rh[self.motor_ind,1,scount] = actflow_predictions[scount,:,3]
# LMID
actflow_lh[self.motor_ind,0,scount] = actflow_predictions[scount,:,0]
# LIND
actflow_lh[self.motor_ind,1,scount] = actflow_predictions[scount,:,1]
#### Now save out only relevant output mask vertices
if vertexmasks:
tmp = np.squeeze(nib.load(self.projectdir + 'data/results/MAIN/MotorRegionsMasksPerSubj/sractflow_smn_outputRH_mask.dscalar.nii').get_data())
rh_ind = np.where(tmp==True)[0]
actflow_rh = actflow_rh[rh_ind,:,:]
tmp = np.squeeze(nib.load(self.projectdir + 'data/results/MAIN/MotorRegionsMasksPerSubj/sractflow_smn_outputLH_mask.dscalar.nii').get_data())
lh_ind = np.where(tmp==True)[0]
actflow_lh = actflow_lh[lh_ind,:,:].copy()
else:
actflow_rh = actflow_rh[self.motor_ind_rh,:,:].copy()
actflow_lh = actflow_lh[self.motor_ind_lh,:,:].copy()
return actflow_rh, actflow_lh
def actflowDecoding(self,trainset,testset,outputfile,
nbootstraps=1000,featsel=False,nproc='max',null=False,verbose=True):
if nproc=='max':
nproc=mp.cpu_count()
# Decoding
for i in range(nbootstraps):
distances_baseline = np.zeros((1,len(self.subjNums)*2)) # subjs * nlabels
distances_baseline[0,:],rmatch,rmismatch, confusion_mats = tools.actflowDecodings(testset,trainset,
effects=True, featsel=featsel,confusion=True,permutation=null,
ncvs=1, nproc=nproc)
##### Save out and append file
# Open/create file
filetxt = open(outputfile,"a+")
# Write out to file
print(np.mean(distances_baseline),file=filetxt)
# Close file
filetxt.close()
if i%100==0 and verbose==True:
print('Permutation', i)
print('\tDecoding accuracy:', np.mean(distances_baseline), '| R-match:', np.mean(rmatch), '| R-mismatch:', np.mean(rmismatch))
def extractSubjActivations(self, subj, df_trials):
"""
extract activations for a sample subject, including motor response
"""
## Set up data parameters
X = tgp.loadTaskTiming(subj,'ALL')
self.stimIndex = np.asarray(X['stimIndex'])
self.stimCond = np.asarray(X['stimCond'])
datadir = self.projectdir + 'data/postProcessing/hcpPostProcCiric/'
h5f = h5py.File(datadir + subj + '_glmOutput_data.h5','r')
self.betas = h5f['taskRegression/ALL_24pXaCompCorXVolterra_taskReg_betas_canonical'][:].copy()
h5f.close()
## Set up task parameters
self.logicRules = ['BOTH', 'NOTBOTH', 'EITHER', 'NEITHER']
self.sensoryRules = ['RED', 'VERTICAL', 'HIGH', 'CONSTANT']
self.motorRules = ['LMID', 'LIND', 'RMID', 'RIND']
self.colorStim = ['RED', 'BLUE']
self.oriStim = ['VERTICAL', 'HORIZONTAL']
self.pitchStim = ['HIGH', 'LOW']
self.constantStim = ['CONSTANT','ALARM']
# Begin extraction for specific trials
n_trials = len(df_trials)
stimData = np.zeros((n_trials,self.betas.shape[0]))
logicRuleData = np.zeros((n_trials,self.betas.shape[0]))
sensoryRuleData = np.zeros((n_trials,self.betas.shape[0]))
motorRuleData = np.zeros((n_trials,self.betas.shape[0]))
respData = np.zeros((n_trials,self.betas.shape[0]))
sensoryRuleIndices = []
motorRespAll = []
for trial in range(n_trials):
logicRule = df_trials.iloc[trial].logicRule
sensoryRule = df_trials.iloc[trial].sensoryRule
motorRule = df_trials.iloc[trial].motorRule
motorResp = df_trials.iloc[trial].motorResp
stim1 = df_trials.iloc[trial].stim1
stim2 = df_trials.iloc[trial].stim2
# if verbose:
# print 'Running actflow predictions for:', logicRule, sensoryRule, motorRule, 'task'
logicKey = 'RuleLogic_' + logicRule
sensoryKey = 'RuleSensory_' + sensoryRule
motorKey = 'RuleMotor_' + motorRule
stimKey = 'Stim_' + stim1 + stim2
motorResp = solveInputs(logicRule, sensoryRule, motorRule, stim1, stim2, printTask=False)
respKey = 'Response_' + motorResp
stimKey_ind = np.where(self.stimCond==stimKey)[0]
logicRule_ind = np.where(self.stimCond==logicKey)[0]
sensoryRule_ind = np.where(self.stimCond==sensoryKey)[0]
motorRule_ind = np.where(self.stimCond==motorKey)[0]
respKey_ind = np.where(self.stimCond==respKey)[0]
stimData[trial,:] = np.real(self.betas[:,stimKey_ind].copy()[:,0])
logicRuleData[trial,:] = np.real(self.betas[:,logicRule_ind].copy()[:,0])
sensoryRuleData[trial,:] = np.real(self.betas[:,sensoryRule_ind].copy()[:,0])
motorRuleData[trial,:] = np.real(self.betas[:,motorRule_ind].copy()[:,0])
respData[trial,:] = np.real(self.betas[:,respKey_ind].copy()[:,0])
motorRespAll.append(motorResp)
sensoryRuleIndices.append(sensoryRule)
self.motorRespAll = motorRespAll
self.stimData = stimData
self.logicRuleData = logicRuleData
self.sensoryRuleData = sensoryRuleData
self.motorRuleData = motorRuleData
self.respData = respData
self.sensoryRuleIndices = sensoryRuleIndices
def extractSubjHiddenRSMActivations(self, subj):
"""
extract activations for a sample subject, including motor response
"""
## Set up data parameters
X = tgp.loadTaskTiming(subj,'ALL')
self.stimIndex = np.asarray(X['stimIndex'])
self.stimCond = np.asarray(X['stimCond'])
datadir = self.projectdir + 'data/postProcessing/hcpPostProcCiric/'
h5f = h5py.File(datadir + subj + '_glmOutput_data.h5','r')
self.betas = h5f['taskRegression/ALL_24pXaCompCorXVolterra_taskReg_betas_canonical'][:].copy()
h5f.close()
## Set up task parameters
self.logicRules = ['BOTH', 'NOTBOTH', 'EITHER', 'NEITHER']
self.sensoryRules = ['RED', 'VERTICAL', 'HIGH', 'CONSTANT']
self.motorRules = ['LMID', 'LIND', 'RMID', 'RIND']
self.colorStim = ['RED', 'BLUE']
self.oriStim = ['VERTICAL', 'HORIZONTAL']
self.pitchStim = ['HIGH', 'LOW']
self.constantStim = ['CONSTANT','ALARM']
total_conds = 28 # 12 rules + 16 stimulus pairings
rsm_activations = np.zeros((28,self.betas.shape[0]))
labels = []
condcount = 0
##
# START
for cond in self.logicRules:
labels.append(cond)
key = 'RuleLogic_' + cond
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
for cond in self.sensoryRules:
labels.append(cond)
key = 'RuleSensory_' + cond
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
for cond in self.motorRules:
labels.append(cond)
key = 'RuleMotor_' + cond
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
# This is nested for loop since stimuli come in pairs
for cond1 in self.colorStim:
for cond2 in self.colorStim:
labels.append(cond1 + cond2)
key = 'Stim_' + cond1 + cond2
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
for cond1 in self.oriStim:
for cond2 in self.oriStim:
labels.append(cond1 + cond2)
key = 'Stim_' + cond1 + cond2
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
for cond1 in self.pitchStim:
for cond2 in self.pitchStim:
labels.append(cond1 + cond2)
key = 'Stim_' + cond1 + cond2
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
for cond1 in self.constantStim:
for cond2 in self.constantStim:
labels.append(cond1 + cond2)
key = 'Stim_' + cond1 + cond2
ind = np.where(self.stimCond==key)[0]
rsm_activations[condcount,:] = np.real(self.betas[:,ind].copy()[:,0])
condcount += 1 # go to next condition
return rsm_activations, labels
def generateHiddenUnitRSMPredictions(self,thresh=0,n_hiddenregions=10,filename='',verbose=False):
"""
Run all predictions for all 64 tasks
"""
hidden_ind = self.hidden_ind
rule_ind = self.rule_ind
all_actflow_unthresh = []
all_actflow_thresh = []
all_true_activity = []
for subj in self.subjNums:
print('Predicting hidden layer activations for subject', subj)
rsm_activations, labels = self.extractSubjHiddenRSMActivations(subj)
tmp_actflow_unthresh = []
tmp_actflow_thresh = []
tmp_true_activity = []
labelcount = 0
for label in labels:
# Dissociate sensory rules from sensory stimuli since stimuli have two stimulus words (e.g., 'REDRED')
if label in ['BOTH', 'NOTBOTH', 'EITHER', 'NEITHER', 'RED', 'VERTICAL', 'HIGH', 'CONSTANT', 'LMID', 'LIND', 'RMID', 'RIND']:
input_units = 'rule'
if label in ['REDRED', 'REDBLUE', 'BLUERED', 'BLUEBLUE']:
input_units = 'RED' # specify sensory rules for sensory activations
if label in ['VERTICALVERTICAL', 'VERTICALHORIZONTAL', 'HORIZONTALVERTICAL', 'HORIZONTALHORIZONTAL']:
input_units = 'VERTICAL' # this is the sensory rule
if label in ['HIGHHIGH', 'HIGHLOW', 'LOWHIGH', 'LOWLOW']:
input_units = 'HIGH'
if label in ['CONSTANTCONSTANT', 'CONSTANTALARM', 'ALARMCONSTANT', 'ALARMALARM']:
input_units = 'CONSTANT'
if input_units!='rule':
input_ind = self._getStimIndices(input_units) # Identify the vertices for stimulus layer of the ANN
unique_input_ind = np.where(np.in1d(input_ind,hidden_ind)==False)[0]
fc = self.fc_input2hidden[input_units]
pc_act = np.matmul(rsm_activations[labelcount,:][unique_input_ind],self.eig_input2hidden[input_units].T)
# Unthresholded actflow
actflow_unthresh = np.matmul(pc_act,fc)
# Thresholded actflow
actflow_thresh = np.multiply(actflow_unthresh,actflow_unthresh>thresh)
if input_units=='rule':
unique_input_ind = np.where(np.in1d(rule_ind,hidden_ind)==False)[0]
fc = self.fc_12rule2hidden
pc_act = np.matmul(rsm_activations[labelcount,:][unique_input_ind],self.eig_12rule2hidden.T)
# Unthresholded actflow
actflow_unthresh = np.matmul(pc_act,fc)
# Thresholded actflow
actflow_thresh = | np.multiply(actflow_unthresh,actflow_unthresh>thresh) | numpy.multiply |
#! /usr/bin/env python3
import numpy as np
import argparse
from sklearn.metrics import adjusted_rand_score as ARI
import dcsbm
## PARSER to give parameter values
formatter = argparse.ArgumentDefaultsHelpFormatter
parser = argparse.ArgumentParser(formatter_class=formatter)
## Set tolerance
parser.add_argument("-t","--tol", type=float, dest="tolerance", default=1e-5, const=True, nargs="?",\
help="Float: convergence criterion (relative difference in average predictive log-likelihood)")
## Set maximum number of iterations
parser.add_argument("-i","--maxiter", type=int, dest="max_iter", default=150, const=True, nargs="?",\
help="Integer: maximum number of iterations for the variational inference algorithm")
## Model type
parser.add_argument("-M", "--model", dest="model", default = 2, type=int,
help="Model: 0 for standard, 1 for normalised, 2 for spherical.")
## Maximum dimension for the embedding
parser.add_argument("-m", "--dimension", dest="dimension", default=50, type=int,
help="Initial dimension of the embedding.")
## Maximum values in the grid search
parser.add_argument("-d", dest="d", default=20, type=int,
help="Maximum value of d in the grid search.")
parser.add_argument("-K", dest="K", default=20, type=int,
help="Maximum value of K in the grid search.")
## Graph type
parser.add_argument("-g", "--graph", dest="graph", default = 'icl2', type=str,
help="Type of graph: icl1, icl2 or icl3.")
## Use the approximated inference procedure
parser.add_argument("-a", "--approx", dest="approx",
action='store_true', help='Use the approximated inference procedure (fast).')
## Parse arguments
args = parser.parse_args()
tolerance = args.tolerance
max_iter = args.max_iter
model = args.model
graph = args.graph
m = args.dimension
d_max = args.d
K_max = args.K
## Import data
if graph == 'icl1':
true_labs = np.loadtxt('Data/labs1.csv', delimiter=',')
X = np.load('Data/X_icl1_emb.npy')[:,:m]
elif graph == 'icl2':
true_labs = np.loadtxt('Data/labs2.csv', delimiter=',')
X = np.load('Data/X_icl2_emb.npy')[:,:m]
elif graph == 'icl3':
true_labs = np.loadtxt('Data/labs3.csv', delimiter=',')
X = np.load('Data/X_icl3_emb.npy')[:,:m]
else:
raise ValueError('Invalid graph.')
## Obtain X_tilde
X_tilde = np.divide(X, np.linalg.norm(X,axis=1)[:,np.newaxis])
## Obtain Theta
Theta = dcsbm.theta_transform(X)
## Calculate the BIC for some combinations of models
mod = ['X','X_tilde','Theta','SCORE'][model]
## Determine the model type
if mod == 'Theta':
mod_type = 'theta'
elif mod == 'X_tilde':
mod_type = 'normalised'
elif mod == 'SCORE':
mod_type = 'score'
else:
mod_type = None
## BIC and ARI
bic = np.zeros((d_max,K_max-1))
ari = | np.zeros((d_max,K_max-1)) | numpy.zeros |
from time import time
import numpy as np
class Tree(object):
def __init__(self, root_node):
self.active_nodes = [root_node]
# end-point nodes
self.integral_nodes = []
self.infeasible_nodes = []
self.selected_node = None
self.optimal_node = None
self.ub = None
self.lb = None
self.finished = None
self._verbose = 0
def solve(self):
start = time()
iteration = 1
print(f"[Branch and Bound]".center(100, "="))
print(f"# of integer variables : {self.active_nodes[0].int_var.size}")
while not self.finished:
iter_start_time = time()
if self._verbose >= 2:
print(f"[Iteration {iteration}: {iter_start_time - start:.2f} seconds]".center(100, "-"))
print(f"Solving unsolved active nodes...")
# check if no more active nodes; terminate if yes
if not self.active_nodes:
self.finished = True
for node in self.integral_nodes:
if self.ub <= node.ub:
self.ub = node.ub
self.optimal_node = node
return self.optimal_node
# solve active nodes (nodes are smart to not re-solve when already solved)
for node in self.active_nodes:
node.solve()
if self._verbose >= 3:
print(f"[Node {node.node_id}]".center(80, "-"))
print(f"Upper bound: {node.ub}")
print(f"Lower bound: {node.lb}")
# classify active nodes
for node in self.active_nodes:
if not node.feasible:
if self._verbose >= 2:
print(f"Found infeasible node")
self.infeasible_nodes.append(node)
elif node.integral:
if self._verbose >= 2:
print(f"Found integral node : {node.ub}")
self.integral_nodes.append(node)
# remove active nodes that have been classified from self.active_nodes
self.active_nodes = [node for node in self.active_nodes if node.feasible]
self.active_nodes = [node for node in self.active_nodes if not node.integral]
# select most promising active node
if self.active_nodes:
self.selected_node = self.active_nodes[
np.argmax([node.ub for node in self.active_nodes])
]
else:
self.selected_node = self.integral_nodes[
np.argmax([node.ub for node in self.integral_nodes])
]
if self._verbose >= 2:
print(f"Complete in {time() - iter_start_time:.2f} CPU seconds.")
print(f"".center(100, "."))
print(f"# of active nodes : {len(self.active_nodes)}")
print(f"# of integral nodes : {len(self.integral_nodes)}")
print(f"# of infeasible nodes : {len(self.infeasible_nodes)}")
print(f"Tightest upper bound : { | np.max(self.selected_node.ub) | numpy.max |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@author: <NAME>, CWI, Amsterdam
<EMAIL>
TODO
fhe full
data of one of the data sets described in
"A Cone-Beam X-Ray CT Data Collection Designed for Machine Learning" by
<NAME>, <NAME>, <NAME>,
<NAME>, <NAME>, <NAME>
"""
import numpy as np
import astra
import os
import imageio
import time
import matplotlib.pyplot as plt
import nesterov_gradient
from scipy.interpolate import RegularGridInterpolator as rgi
def rotate_astra_vec_geom(vecs, theta):
s = np.asmatrix(vecs[:,0:3])
d = | np.asmatrix(vecs[:,3:6]) | numpy.asmatrix |
# 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]) | numpy.array |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
This file contains the experiments in the active scenario of [Haddenhorst2021].
In order to rerun these, UNCOMMENT in "Part 4" below the corresponding lines and
then execute this file.
[Haddenhorst2021]: <NAME>, <NAME>, <NAME> and E.Hüllermeier, Testification of Condorcet Winners in Dueling Bandits, Proceedings of UAI, 2021
"""
import ReciprocalRelations as rr
import TestEnvironment as tenv
import TestingComponent as tc
import numpy as np
import DeterministicTestingComponent as dtc
import SELECT as select
import math
import matplotlib.pyplot as plt
nr_items, decimal_precision = 5,3
np.set_printoptions(precision=3)
###############################################################################
# PART 1: Define 'find_CW_with_symm_test', 'SELECT_then_verify'
# and 'buf_SPRT'
###############################################################################
def find_CW_with_symm_test(TE, h, gamma):
"""
This is an implementation of the Algorithm NTS from the paper.
"""
SymmTC = tc.Symmetric_TestingComponent(TE.N, TE.R, h=float(h), gamma=gamma)
sampling_strategy = dtc.Optimal_Deterministic_CW_Tester(len(TE.N))
for t in range(500000):
[i,j] = sampling_strategy.getQuery()
while not SymmTC.G.has_edge(i,j) and not SymmTC.G.has_edge(j,i):
feedback = TE.pullArmPair(i,j)
SymmTC.update(i,j,feedback)
if SymmTC.TC():
SymmTC.DC()
return SymmTC.find_CW(), SymmTC.time
sampling_strategy.giveFeedback(feedback)
def SELECT_then_verify(TE,h,gamma, variant = "Hoeffding"):
"""
This is the implementation from SELECT-then-verify from the paper.
The internal hypothesis test for verifying the output of SELECT can either
be the non-sequential Hoeffding-bound test (with 'variant="Hoeffding"')
or the corresponding SPRT (with 'variant="SPRT"').
"""
assert variant=="Hoeffding" or variant=="SPRT", "'variant' has to be 'Hoeffding' or 'SPRT'"
m = TE.P.m
epsilon = -np.log(0.5*gamma)/np.log(np.log2(m))
m_h = math.floor((1+epsilon)*math.log(2)/2*math.log(math.log(m,2),2)/(h*h))+1
CW_M, itera = select.select(list(np.arange(m)), m_h, TE.pullArmPair)
CW_M = int(CW_M)
# print("Output of SELECT:",CW_M,"(after ",itera," iterations)")
# TE.show()
if variant=="Hoeffding":
t0 = np.ceil(2/(h**2) * np.log(2*(m-1)/gamma))
w = np.zeros(m)
for j in range(0,m):
if CW_M is not j:
for t in range(0,int(t0)):
buf = TE.pullArmPair(CW_M,j)
w[j] += buf #Increases by 1 if CW_M has won
if w[j]/t0 < 0.5:
# print("w",w)
return(False)
return(CW_M)
if variant=="SPRT":
for j in range(0,m):
if CW_M is not j:
winner = buf_SPRT(TE,h,gamma/(2*(m-1)),CW_M,j)
if winner != CW_M:
return(False)
return(CW_M)
def buf_SPRT(TE,h,gamma,i,j):
"""
This function conducts a SPRT (with parameters h,gamma) in order to decide
whether the (i,j)-entry of TE.P is >1/2 or <1/2.
"""
N = 1
C = (1/(2*N)) * np.ceil(np.log( (1-gamma) / gamma ) / np.log( (0.5+h) / (0.5-h) ))
w = TE.pullArmPair(i,j)
while 0.5-C < w/N and w/N< 0.5+C:
w += TE.pullArmPair(i,j)
C = (1/(2*N)) * np.ceil(np.log( (1-gamma) / gamma ) / np.log( (0.5+h) / (0.5-h) ))
N = N+1
if w/N >= 0.5+C:
return(i)
else:
return(j)
###############################################################################
# PART 3: Define the evaluation functions 'experiments_one', 'experiment_two'
# 'experiment_three' as well as 'generate_main_figure'.
###############################################################################
def experiments_one(m,h,gamma,nr_iterations=100, real_h = 0.05, has_CW = "No",verify_variant="SPRT"):
"""
This function compares NTS with SELECT-then-verify. It is required for the
function "experiment_two".
"""
assert has_CW=="No" or has_CW=="Yes" or has_CW=="Both", "'has_CW' has to be 'Yes','No' or 'Both'."
results = dict()
results["NTS_output"] =list()
results["NTS_time"] = list()
results["S_t_verify_output"] = list()
results["S_t_verify_time"] = list()
results["Truth"] = list()
for iteration in range(0,nr_iterations):
# Step 1: Sample a reciprocal relation, create a TE and a dictionary to save results.
if has_CW == "No":
P, buf = rr.sampleCW_boundedFromOneHalf(m,real_h,decimal_precision=3)
elif has_CW == "Yes":
P = rr.sampleNotCW_boundedFromOneHalf(m,real_h,max_tries=10000,decimal_precision=3)
else:
P = rr.sampleReciprocal(m,decimal_precision=3)
P = rr.__EnforceBoundedFromOneHalf__(P,real_h)
results["Truth"].append(rr.get_CW(P))
# Step 2: Run and log our NTS
TE = tenv.TestEnvironment(P)
current_output = find_CW_with_symm_test(TE, h, gamma)
results["NTS_output"].append(current_output[0])
results["NTS_time"].append(TE.time)
# Step 3: Run and log SELECT_then_verify
TE = tenv.TestEnvironment(P)
current_output = SELECT_then_verify(TE, h, gamma,variant=verify_variant)
results["S_t_verify_output"].append(current_output)
results["S_t_verify_time"].append(TE.time)
# Step 4: Calculate the accuracy of both algorithms and return the results
nr_correct_NTS ,nr_correct_S_t_verify = 0,0
for i in range(0,nr_iterations):
if results["Truth"][i] == results["NTS_output"][i]:
nr_correct_NTS += 1
if results["Truth"][i] == results["S_t_verify_output"][i]:
nr_correct_S_t_verify += 1
results["Acc_NTS"] = nr_correct_NTS / nr_iterations
results["Acc_S_t_verify"] = nr_correct_S_t_verify / nr_iterations
results["NTS_mean_time"] = np.mean(results["NTS_time"])
results["S_t_verify_mean_time"] = np.mean(results["S_t_verify_time"])
# print(results)
# print("NTS: mean",np.mean(results["NTS_time"]),"\t std:",np.std(results["NTS_time"]), "\t Accuracy:", results["Acc_NTS"])
# print("SELECT_then_verify: mean",np.mean(results["S_t_verify_time"]),"\t std:",np.std(results["S_t_verify_time"]), "\t Accuracy:", results["Acc_S_t_verify"])
return(results)
def experiment_two(m=5, real_h=0.1, h=0.3, file_name ="plot",nr_iterations =25000,has_CW = "No",verify_variant="SPRT"):
"""
This function compares NTS with SELECT-then-verify for the given parameters,
saves the observed accuracies and averaged termination times and plots the
results.
"""
gammas = [0.001,0.005,0.01,0.015,0.02,0.03,0.05,0.075,0.1,0.125,0.15,0.2,0.25,0.35,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.7,0.95,0.99]
x_NTS = np.zeros(len(gammas))
y_NTS = np.zeros(len(gammas))
x_StV = np.zeros(len(gammas))
y_StV = np.zeros(len(gammas))
print("Progress for "+str(file_name)+" (.. out of "+str(len(gammas))+"): ")
for i in range(0,len(gammas)):
print(i,end=",")
buf = experiments_one(m,h,gammas[i],nr_iterations,real_h=real_h,has_CW = has_CW)
x_NTS[i] = buf["NTS_mean_time"]
x_StV[i] = buf["S_t_verify_mean_time"]
y_NTS[i] = buf["Acc_NTS"]
y_StV[i] = buf["Acc_S_t_verify"]
plt.plot(x_NTS,y_NTS, marker = "^", label="NTS")
plt.plot(x_StV, y_StV, marker = "o", label="SELECT-then-verify")
plt.xlabel("Iterations")
plt.ylabel("Success Rate")
plt.legend()
plt.title("h="+str(h))
plt.savefig(str(file_name)+"_plot.png",dpi=300)
plt.show()
np.savetxt(str(file_name)+"_results.csv",np.asarray([x_NTS,y_NTS,x_StV,y_StV]),delimiter=",")
# print(x_NTS,y_NTS)
print("Done.")
def experiment_three_help(m,h,gamma,nr_iterations=100, real_h = 0.05, has_CW = "No",verify_variant="SPRT"):
"""
This is an appropriate modification of 'experiments_one' from above
Each line of code that has been modified is indicated with a comment '[CHANGE]',
together with the original code.
"""
assert has_CW=="No" or has_CW=="Yes" or has_CW=="Both", "'has_CW' has to be 'Yes','No' or 'Both'."
results = dict()
results["NTS_output"] =list()
results["NTS_time"] = list()
results["S_t_verify_output"] = list()
results["S_t_verify_time"] = list()
results["Truth"] = list()
for iteration in range(0,nr_iterations):
# Step 1: Sample a reciprocal relation, create a TE and a dictionary to save results.
if has_CW == "No":
#P, buf = rr.sampleCW_boundedFromOneHalf(m,real_h,decimal_precision=3) [CHANGE]
P, buf = rr.sampleCW_exactly_h(m,real_h,decimal_precision=3)
elif has_CW == "Yes":
# P = rr.sampleNotCW_boundedFromOneHalf(m,real_h,max_tries=10000,decimal_precision=3) [CHANGE]
P = rr.sampleNotCW_exactly_h(m, real_h,max_tries = 100000,decimal_precision = 3)
else:
# P = rr.sampleReciprocal(m,decimal_precision=3) [CHANGE]
# P = rr.__EnforceBoundedFromOneHalf__(P,real_h) [CHANGE]
P = rr.sampleRecRel_exactly_h(m,real_h,decimal_precision = 3)
results["Truth"].append(rr.get_CW(P))
# Step 2: Run and log our NTS
TE = tenv.TestEnvironment(P)
current_output = find_CW_with_symm_test(TE, h, gamma)
results["NTS_output"].append(current_output[0])
results["NTS_time"].append(TE.time)
# Step 3: Run and log SELECT_then_verify
TE = tenv.TestEnvironment(P)
current_output = SELECT_then_verify(TE, h, gamma,variant=verify_variant)
results["S_t_verify_output"].append(current_output)
results["S_t_verify_time"].append(TE.time)
# Step 4: Calculate the accuracy of both algorithms and return the results
nr_correct_NTS ,nr_correct_S_t_verify = 0,0
for i in range(0,nr_iterations):
if results["Truth"][i] == results["NTS_output"][i]:
nr_correct_NTS += 1
if results["Truth"][i] == results["S_t_verify_output"][i]:
nr_correct_S_t_verify += 1
results["Acc_NTS"] = nr_correct_NTS / nr_iterations
results["Acc_S_t_verify"] = nr_correct_S_t_verify / nr_iterations
results["NTS_mean_time"] = np.mean(results["NTS_time"])
results["S_t_verify_mean_time"] = np.mean(results["S_t_verify_time"])
return(results)
def experiment_three(m=5, gamma = 0.05, real_hs=[0.1,0.2,0.3,0.4], h=0.1, file_name ="plot",nr_iterations =25000,has_CW = "No",verify_variant="SPRT"):
"""
This is a simple modification of experiment_two.
-- instead of modifying gamma, we modify the value of real_h.
"""
# gammas = [0.001,0.005,0.01,0.015,0.02,0.03,0.05,0.075,0.1,0.125,0.15,0.2,0.25,0.35,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.7,0.95,0.99]
len_real_hs = len(real_hs)
x_NTS = np.zeros(len_real_hs)
y_NTS = np.zeros(len_real_hs)
x_StV = np.zeros(len_real_hs)
y_StV = np.zeros(len_real_hs)
print("Progress for "+str(file_name)+" (.. out of "+str(len_real_hs)+"): ")
for i in range(0,len_real_hs):
print(i,end=",")
buf = experiment_three_help(m,h,gamma,nr_iterations,real_h=real_hs[i],has_CW = has_CW)
x_NTS[i] = buf["NTS_mean_time"]
x_StV[i] = buf["S_t_verify_mean_time"]
y_NTS[i] = buf["Acc_NTS"]
y_StV[i] = buf["Acc_S_t_verify"]
plt.plot(real_hs,x_NTS, marker = "^", label="NTS")
plt.plot(real_hs, x_StV, marker = "o", label="SELECT-then-verify")
plt.xlabel("real_h")
plt.ylabel("Iterations")
plt.legend()
plt.title("h="+str(h))
plt.savefig(str(file_name)+"_plot.png",dpi=300)
plt.show()
np.savetxt(str(file_name)+"_results.csv",np.asarray([real_hs,x_NTS,y_NTS,x_StV,y_StV]),delimiter=",")
print("Done.")
# OUTPUT THE RESULTS AS A TABLE:
print("The results in form of [h, T A^NTS, Acc. A^NTS, T^StV, Acc StV] are:")
for i in range(0,len_real_hs):
print(real_hs[i],x_NTS[i],y_NTS[i],x_StV[i],y_StV[i])
##############################################################################
# The following function helps to create Figure 1 of our paper.
##############################################################################
def generate_main_figure():
a = | np.loadtxt("MAIN_h02_results.csv",delimiter=",") | numpy.loadtxt |
# 2D quadratic function
import math
import numpy as np
import numdifftools as nd
from pystatreduce.quantity_of_interest import QuantityOfInterest
class Paraboloid2D(QuantityOfInterest):
def __init__(self, systemsize, tuple):
QuantityOfInterest.__init__(self, systemsize)
self.extra_args = tuple
self.quadratic_matrix = np.diag([50,1])
def eval_QoI(self, mu, xi):
theta = self.extra_args[0]
# rotation_mat = [cos(theta) -sin(theta);
# sin(theta) cos(theta)]
rotation_mat = np.array([[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]])
xi_hat = rotation_mat.dot(xi)
fval = 50*(mu[0]+xi_hat[0])**2 + (mu[1] + xi_hat[1])**2
return fval
def eval_QoIGradient(self, mu, xi):
"""
Use finite difference to compute gradient.
"""
def func(xi) :
return self.eval_QoI(mu, xi)
G = nd.Gradient(func)(xi)
return G
def eval_QoIHessian(self, mu, xi):
"""
Use finite difference to compute Hessian.
"""
def func(xi) :
return self.eval_QoI(mu, xi)
H = nd.Hessian(func)(xi)
return H
def eval_QoI_analyticalmean(self, mu, cov):
assert self.extra_args[0] == 0.0, "This function only works for theta = 0"
mu_j = np.trace(np.matmul(self.quadratic_matrix, cov)) \
+ mu.dot(self.quadratic_matrix.dot(mu))
return mu_j
class Paraboloid3D(QuantityOfInterest):
def __init__(self, systemsize):
QuantityOfInterest.__init__(self, systemsize)
self.quadratic_matrix = np.diag([50, 25, 1])
def eval_QoI(self, mu, xi):
return 50*(mu[0]+xi[0])**2 + 25*(mu[1] + xi[1])**2 + (mu[2] + xi[2])**2
def eval_QoIGradient(self, mu, xi):
rv = mu + xi
grad = np.array([100*rv[0], 50*rv[1], 2*rv[2]])
return grad
def eval_QoIHessian(self, mu, xi):
return np.diag([100, 50, 2])
def eval_QoI_analyticalmean(self, mu, cov):
mu_j = np.trace(np.matmul(self.quadratic_matrix, cov)) \
+ mu.dot(self.quadratic_matrix.dot(mu))
return mu_j
def eval_QoI_analyticalvariance(self, mu, cov):
mat1 = np.matmul(self.quadratic_matrix, cov)
vec1 = self.quadratic_matrix.dot(cov.dot(self.quadratic_matrix.dot(mu)))
var_j = 2*np.trace(np.matmul(mat1,mat1)) + 4*np.dot(mu, vec1)
return var_j
class Paraboloid5D(QuantityOfInterest):
def __init__(self, systemsize):
QuantityOfInterest.__init__(self, systemsize)
self.quadratic_matrix = | np.diag([50, 40, 30, 20, 1]) | numpy.diag |
import numpy as np
import random
import pandas as pd
from matplotlib import pyplot as plt
'''
Perceptron algorithm that finds the idea weights given a data set and labels
Parameters
----------
coords: data points in 2 dimensions ([x1, x2])
labels: binary target output for each data point (-1 or 1)
epochs: number of iterations that needs to be run
misclassifiedList
Returns
-------
w: resulting weight vector after learning the data points
'''
def perceptron_algorithm(coords, labels, epochs, misclassifiedList):
w = np.zeros((coords.shape[1]) + 1)
for i in range(epochs):
misclassified = 0
for x, y in zip(coords, labels):
dotProd = np.dot(x, w[1:]) + w[0]
target = 1.0 if (dotProd > 0.0) else -1.0
if(target != y):
print(y, target, "classified incorrectly")
misclassified += 1
w[1:] += y * x
w[0] += x[0]
else:
print(y, target, "classified correctly")
print("PRINTING W", w)
misclassifiedList.append(misclassified)
return w
if __name__ == "__main__":
# Set up the random generator seed
np.random.seed(121232141)
# Total number of random points
total = 1000
# Create 20 random points that are linearly separable
A = 2 * np.random.random_sample((total//2, 2)) + 0
B = 2 * np.random.random_sample((total//2, 2)) - 2
# Create the lists that hold the respective binary labels for the 20 points
A1 = np.ones((total//2, 1))
B1 = np.negative(np.ones((total//2, 1)))
x = np.linspace(-3, 3)
y = -1 * x
# Plot the scatter points and the target function, y = -x
plt.plot(x, y, color="blue", label="target function f")
plt.scatter(A[:,0], A[:,1], marker="o")
plt.scatter(B[:,0], B[:,1], marker="x")
plt.title("PLA Testing")
plt.xlabel("x1")
plt.ylabel("x2")
coords = | np.concatenate((A, B)) | numpy.concatenate |
from __future__ import absolute_import, division, print_function, unicode_literals
from banzai.utils import stats
import numpy as np
from numpy import ma
np.random.seed(10031312)
def test_median_axis_none_mask_none():
for i in range(25):
size = np.random.randint(1, 10000)
mean = np.random.uniform(-1000, 1000)
sigma = np.random.uniform(0, 1000)
a = np.random.normal(mean, sigma, size)
expected = np.median(a.astype(np.float32))
actual = stats.median(a)
assert np.float32(expected) == actual
def test_median_2d_axis_none_mask_none():
for i in range(5):
size1 = np.random.randint(1, 300)
size2 = np.random.randint(1, 300)
mean = np.random.uniform(-1000, 1000)
sigma = np.random.uniform(0, 1000)
a = np.random.normal(mean, sigma, size=(size1, size2))
expected = np.median(a.astype(np.float32))
actual = stats.median(a)
assert np.float32(expected) == actual
def test_median_3d_axis_none_mask_none():
for i in range(5):
size1 = np.random.randint(1, 50)
size2 = np.random.randint(1, 50)
size3 = np.random.randint(1, 50)
mean = np.random.uniform(-1000, 1000)
sigma = np.random.uniform(0, 1000)
a = np.random.normal(mean, sigma, size=(size1, size2, size3))
expected = np.median(a.astype(np.float32))
actual = stats.median(a)
assert np.float32(expected) == actual
def test_median_2d_axis_0_mask_none():
for i in range(5):
size1 = np.random.randint(1, 300)
size2 = np.random.randint(1, 300)
mean = np.random.uniform(-1000, 1000)
sigma = np.random.uniform(0, 1000)
a = np.random.normal(mean, sigma, size=(size1, size2))
expected = np.median(a.astype(np.float32), axis=0)
actual = stats.median(a, axis=0)
np.testing.assert_allclose(actual, expected.astype(np.float32), atol=1e-6)
def test_median_2d_axis_1_mask_none():
for i in range(5):
size1 = np.random.randint(1, 300)
size2 = np.random.randint(5, 300)
mean = np.random.uniform(-1000, 1000)
sigma = np.random.uniform(0, 1000)
a = np.random.normal(mean, sigma, size=(size1, size2))
expected = np.median(a.astype(np.float32), axis=1)
actual = stats.median(a, axis=1)
np.testing.assert_allclose(actual, expected.astype(np.float32), atol=1e-6)
def test_median_3d_axis_0_mask_none():
for i in range(5):
size1 = np.random.randint(5, 50)
size2 = np.random.randint(1, 50)
size3 = np.random.randint(1, 50)
mean = np.random.uniform(-1000, 1000)
sigma = np.random.uniform(0, 1000)
a = np.random.normal(mean, sigma, size=(size1, size2, size3))
expected = np.median(a.astype(np.float32), axis=0)
actual = stats.median(a, axis=0)
np.testing.assert_allclose(actual, expected.astype(np.float32), atol=1e-6)
def test_median_3d_axis_1_mask_none():
for i in range(5):
size1 = np.random.randint(1, 50)
size2 = np.random.randint(5, 50)
size3 = np.random.randint(1, 50)
mean = np.random.uniform(-1000, 1000)
sigma = np.random.uniform(0, 1000)
a = np.random.normal(mean, sigma, size=(size1, size2, size3))
expected = np.median(a.astype(np.float32), axis=1)
actual = stats.median(a, axis=1)
np.testing.assert_allclose(actual, expected.astype(np.float32), atol=1e-6)
def test_median_3d_axis_2_mask_none():
for i in range(5):
size1 = np.random.randint(1, 50)
size2 = np.random.randint(1, 50)
size3 = np.random.randint(5, 50)
mean = np.random.uniform(-1000, 1000)
sigma = np.random.uniform(0, 1000)
a = np.random.normal(mean, sigma, size=(size1, size2, size3))
expected = np.median(a.astype(np.float32), axis=2)
actual = stats.median(a, axis=2)
np.testing.assert_allclose(actual, expected.astype(np.float32), atol=1e-6)
def test_median_axis_none_mask():
for i in range(25):
size = np.random.randint(1, 10000)
mean = np.random.uniform(-1000, 1000)
sigma = np.random.uniform(0, 1000)
a = np.random.normal(mean, sigma, size)
value_to_mask = np.random.uniform(0, 1.0)
mask = np.random.uniform(0, 1, size) < value_to_mask
expected = ma.median(ma.array(a, mask=mask, dtype=np.float32))
actual = stats.median(a, mask=mask)
assert np.float32(expected) == actual
def test_median_2d_axis_none_mask():
for i in range(5):
size1 = np.random.randint(1, 300)
size2 = | np.random.randint(1, 300) | numpy.random.randint |
import os
import pandas as pd
import numpy as np
import seaborn as sns
from matplotlib import pyplot as plt
import warnings
warnings.filterwarnings("ignore")
def read_p1(problem_name):
x = pd.read_csv(os.path.join("data", "p1", f"p1_{problem_name}_X.dat"), sep=" ", header=None, engine='python')
y = pd.read_csv(os.path.join("data", "p1", f"p1_{problem_name}_y.dat"), header=None)
y = y.values.reshape((-1,))
x = x.values
return x, y
def plot_points(x, y):
sns.scatterplot(
x=x[:, 0],
y=x[:, 1],
hue=y,
palette=sns.color_palette("muted", n_colors=2)
)
def plot_separator(w, bias):
slope = -w[0] / w[1]
intercept = -bias / w[1]
limits = plt.axes().get_xlim()
x = | np.arange(limits[0], limits[1]) | numpy.arange |
import numpy as np
import time
#from scipy.linalg import sqrtm
ABSERR = 10E-10
def compute_psd_factorization(X,r,nIterates=100,method='multiplicative',Init = None,silent=False):
n1,n2 = X.shape
if Init is None:
A = gen_psdlinmap(n1,r)
B = gen_psdlinmap(n2,r)
else:
A,B = Init
Errs = np.zeros((nIterates,))
start = time.process_time()
if not(silent):
print(' It. # | Error | Time Taken')
for ii in range(nIterates):
t_start = time.time()
if method == 'multiplicative':
try:
B = update_multiplicative(A, B, X)
except:
print('d')
B = update_multiplicative_damped(A, B, X)
try:
A = update_multiplicative(B, A, X.T)
except:
print('d')
A = update_multiplicative_damped(B, A, X.T)
if method == 'multiplicativeaccelerated':
B = update_multiplicativeaccelerated(A, B, X)
A = update_multiplicativeaccelerated(B, A, X.T)
if method == 'fpgm':
B = update_fpgm(A, B, X, 10)
B = np.real(B)
A = update_fpgm(B, A, X.T, 10)
AB = linmap_dot(A, B)
Errs[ii,] = np.linalg.norm(AB-X)/np.linalg.norm(X)
elapsed_time = time.time() - t_start
np.save('A.npy',A)
np.save('B.npy',B)
np.save('Errs.npy',Errs)
if not(silent):
print(str(ii+1) + ' | ' + str(Errs[ii,]) + ' | ' + str(elapsed_time))
time_elapsed = time.process_time() - start
print('Average Iteration Time: ' + str(time_elapsed/nIterates))
print('Total Time: ' + str(time_elapsed))
return {'A': A, 'B': B, 'Errors' : Errs, 'ElapsedTime' : time_elapsed}
def sqrtm(X):
R_org = np.linalg.cholesky(X).T
R = R_org.copy()
ERR = 100.0
c = 0
while ERR > ABSERR:
c += 1
Rnew = 0.5 * (R + np.linalg.inv(R).T)
ERR = np.linalg.norm(Rnew-R) / np.linalg.norm(R)
R = Rnew
#print(c)
Xhalf = R.T @ R_org
return (Xhalf + Xhalf.T) / 2
def gen_psd(q):
"""
Random PSD matrix of size (q,q)
from Wishart distribution
"""
G = np.random.randn(q,q)
G = G @ G.T * (1/q)
return G
def gen_psdlinmap(d,q):
"""
Generate Random linear map of dimensions d,q,q
Each "row" is a q x q random symmetric PSD matrix
"""
A = np.zeros((d,q,q))
for i in range(d): # The rows of A are PSD matrices
A[i,:,:] = gen_psd(q)
return A
def gen_cpmap(d,q,sym=False):
"""
Generate random linear map of dimensions d,q,q
Each row is a q x q random symmetric matrix
"""
# Random linear map
A = np.random.randn(d,q,q) / np.sqrt(q*d)
if sym==True:
for i in range(d):
A[i,:,:] = A[i,:,:] + A[i,:,:].T
return A
def applycpmap(A,X):
d,q,_ = A.shape
AX = np.zeros((q,q))
for i in range(d):
W = A[i,:,:]
W = (W @ X) @ W.T
W = (W + W.T) / 2
AX += W
return AX
def linmap_dot(A,B):
"""
Given inputs two linear maps of size d_1,q,q and d_2,q,q
Returns a matrix of size d1,d_2 by `contracting' these linear maps
"""
d1,_,_ = A.shape
d2,_,_ = B.shape
X = np.zeros((d1,d2))
for i in range(d1):
for j in range(d2):
X[i,j] = np.trace( A[i,:,:].T @ B[j,:,:] )
return X
def applylinmap(A,X):
"""
Input A is a linear map of size d,q,q
and X is a matrix of size q,q
Output is A(X) a vector of size d
"""
d,q,_ = A.shape
AX = np.zeros((d,))
for i in range(d):
AX[i,] = np.trace(A[i,:,:].T @ X)
return AX
def applytransposelinmap(A,x):
"""
Input A is a linear map of size d,q,q
and x is a vector of size d
Output is A^T x a matrix of size q,q
"""
d,q,_ = A.shape
AtX = | np.zeros((q,q)) | numpy.zeros |
import yaml
from boids import Boids
from copy import deepcopy
import numpy as np
boids = Boids()
before = deepcopy(boids.boids)
move_to_middle = 0.01
boids.fly_towards_the_middle(boids.boids,move_to_middle)
after = boids.boids
fixture = {"before": np.array(before).tolist(),
"after": np.array(after).tolist(),
"move_to_middle_strength": move_to_middle}
fixture_file = open("fixture_fly_towards_the_middle.yml",'w')
fixture_file.write(yaml.dump(fixture))
fixture_file.close()
boids = Boids()
before=deepcopy(boids.boids)
alert_distance = 100
boids.fly_away_from_nearby_boids(boids.boids,alert_distance)
after= boids.boids
fixture={"before":np.array(before).tolist(),
"after": | np.array(after) | numpy.array |
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import torchvision.models as torch_models
import os.path as osp
import os
import time
from datetime import datetime
from collections import defaultdict as dd
import utils
import numpy as np
def soft_cross_entropy(pred, soft_targets, weights=None):
if weights is not None:
return torch.mean(torch.sum(- soft_targets * F.log_softmax(pred, dim=1) * weights, 1))
else:
return torch.mean(torch.sum(- soft_targets * F.log_softmax(pred, dim=1), 1))
def train_step(model, train_loader, criterion, optimizer, epoch, device, log_interval=10, writer=None):
model.train()
train_loss = 0.
correct = 0
total = 0
train_loss_batch = 0
epoch_size = len(train_loader.dataset)
t_start = time.time()
for batch_idx, (inputs, targets) in enumerate(train_loader):
inputs, targets = inputs.to(device), targets.to(device)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
if writer is not None:
pass
train_loss += loss.item()
_, predicted = outputs.max(1)
total += targets.size(0)
if len(targets.size()) == 2:
# Labels could be a posterior probability distribution. Use argmax as a proxy.
target_probs, target_labels = targets.max(1)
else:
target_labels = targets
correct += predicted.eq(target_labels).sum().item()
prog = total / epoch_size
exact_epoch = epoch + prog - 1
acc = 100. * correct / total
train_loss_batch = train_loss / total
# if (batch_idx + 1) % log_interval == 0:
# print('[Train] Epoch: {:.2f} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tAccuracy: {:.1f} ({}/{})'.format(
# exact_epoch, batch_idx * len(inputs), len(train_loader.dataset), 100. * batch_idx / len(train_loader),
# loss.item(), acc, correct, total))
t_end = time.time()
t_epoch = int(t_end - t_start)
acc = 100. * correct / total
return train_loss_batch, acc
def test_step(model, test_loader, criterion, device, epoch=0., silent=True, writer=None, victimmodel = None):
model.eval()
test_loss = 0.
correct = 0
correct2 = 0
total = 0
t_start = time.time()
with torch.no_grad():
for inputs, targets in test_loader:
inputs, targets = inputs.to(device), targets.to(device)
outputs = model(inputs)
#loss = criterion(outputs, targets)
nclasses = outputs.size(1)
#test_loss += loss.item()
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
if victimmodel != None:
outputs2 = victimmodel(inputs)
_, predicted2 = outputs2.max(1)
correct2 += predicted.eq(predicted2).sum().item()
acc2 = 100. * correct2 / total
t_end = time.time()
t_epoch = int(t_end - t_start)
acc = 100. * correct / total
test_loss /= total
if not silent:
print('[Test] Epoch: {}\tLoss: {:.6f}\tAcc: {:.1f}% ({}/{})'.format(epoch, test_loss, acc,
correct, total))
if writer is not None:
writer.add_scalar('Loss/test', test_loss, epoch)
writer.add_scalar('Accuracy/test', acc, epoch)
if victimmodel == None:
return test_loss, acc
else:
return test_loss, acc, acc2
def train_model(model, trainset, out_path, batch_size=64, criterion_train=None, criterion_test=None, testset=None,
device=None, num_workers=10, lr=0.1, momentum=0.5, lr_step=30, lr_gamma=0.1, resume=None,
epochs=100, log_interval=100, weighted_loss=False, checkpoint_suffix='', optimizer=None, scheduler=None,
writer=None, filerawacc=None, filerawacc2 = None, length = None, victimmodel = None, **kwargs):
if device is None:
device = torch.device('cuda')
run_id = str(datetime.now())
train_loader = DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=True)
if testset is not None:
test_loader = testset
else:
test_loader = None
if weighted_loss:
if not isinstance(trainset.samples[0][1], int):
print('Labels in trainset is of type: {}. Expected: {}.'.format(type(trainset.samples[0][1]), int))
class_to_count = dd(int)
for _, y in trainset.samples:
class_to_count[y] += 1
class_sample_count = [class_to_count[c] for c, cname in enumerate(trainset.classes)]
print('=> counts per class: ', class_sample_count)
weight = | np.min(class_sample_count) | numpy.min |
import logging
import os
import numpy as np
import pandas as pd
import sqlalchemy
from cached_property import cached_property
from scipy.interpolate import interp1d
from aqueduct.errors import Error
class RiskService(object):
def __init__(self, user_selections):
# DB Connection
self.engine = sqlalchemy.create_engine(os.getenv('POSTGRES_URL'))
self.metadata = sqlalchemy.MetaData(bind=self.engine)
self.metadata.reflect(self.engine)
# BACKGROUND INFO
self.flood_types = ["riverine", "coastal"]
self.exposures = ["gdpexp", "popexp", "urban_damage_v2"]
self.geogunits = ["geogunit_103", "geogunit_108"]
self.scenarios = {"business as usual": ['rcp8p5', 'ssp2', "bau"],
"pessimistic": ['rcp8p5', 'ssp3', "pes"],
"optimistic": ['rcp4p5', 'ssp2', "opt"],
"rcp8p5": ['rcp8p5', 'ssp3', "pes"],
"rcp4p5": ['rcp8p5', 'ssp2', "bau"]}
self.models = {"riverine": ["gf", "ha", "ip", "mi", "nr"],
# "coastal": ["wt"]}
"coastal": ["95", "50", "05"]}
self.years = [2010., 2030., 2050., 2080.]
self.ys = [str(x)[0:4] for x in self.years]
self.rps = [2, 5, 10, 25, 50, 100, 250, 500, 1000]
self.rps_names = ["rp" + str(x).zfill(5) for x in self.rps]
# MANDATORY USER INPUTS
self.flood = user_selections.get("flood") # Flood type
self.exposure = user_selections.get("exposure") # Exposure type
self.geogunit_unique_name = user_selections.get("geogunit_unique_name") # Unique geographical unit name
self.sub_scenario = user_selections.get(
"sub_scenario") # Subsidence option (Will always be no for Riverine floods)
self.existing_prot = user_selections.get(
"existing_prot") # User input for protection standard (triggers on-the-fly calculation)
self.scenario = user_selections.get("scenario")
self.geogunit, self.geogunit_name, self.geogunit_type, self.clim, self.socio, self.scen_abb, self.sub_abb, self.df_precalc, self.prot_pres, self.risk_analysis = self.user_selections()
# Scenario abbreviation
self.mods = self.models.get(self.flood)
def user_selections(self):
"""
Purpose: Gather all necessary inputs to run any analysis
Input:
flood: Riverine of Coastal (User must select)
Geogunit_unique_name: geographical unit name from website. (User must select)
Website should use list of unique names to avoid selecting more than one unit
Scenario: Business as usual, Pessimistic, Optimistic
sub_scenario: Yes (defaul(t), No does the user want to consider subsidence? Only relevant for coastal)
existing_prot: Default protection standard. User can input their own or, which will trigger on-the-fly calculations
Output:
geogunit unit - (geogunit_103 for cities, geogunit_108 for everything else)
geogunit_name - original (ie non-unique) name
geogunit_type - City, State, Country, Basin
clim - rcp4p5, rcp8p4 (climate scenario associated with overall scenario)
socio - base, ssp2, ssp3 (socioeconomic scenario associated with overall scenario)
sub_scenario- Yes, No (Is subsidence included?)
sub_abb - wtsub or nosub (code name for subsidence. wtsub = with sub)
prot_pres - default protection standard for unit as a whole
risk_analysis - can we use precalculated risk data, or do we need to calculate on-the-fly?
"""
# GEOGUNIT INFO
fids, geogunit_name, geogunit_type = pd.read_sql_query(
"SELECT fids, name, type FROM lookup_master where uniqueName = '{0}' ".format(self.geogunit_unique_name),
self.engine).values[0]
geogunit = "geogunit_103" if geogunit_type.lower() == "city" else "geogunit_108"
# IMPACT DRIVER INFO (climate and socioeconomc scenarios
clim, socio, scen_abb = self.scenarios.get(self.scenario)
# SUBSIDENCE INFO
# Make sure subsidence is turned off for river floods
sub_abb = "wtsub" if self.sub_scenario else "nosub"
# DEFAULT DATA
defaultfn = "precalc_agg_{0}_{1}_{2}".format(self.flood, geogunit_type.lower(), sub_abb)
logging.info(f'[RISK - user_selection]: {str(defaultfn)}')
df_precalc = pd.read_sql_query("SELECT * FROM {0} where id like '{1}'".format(defaultfn, geogunit_name),
self.engine, index_col='id')
# PROTECTION STANDARDS and RISK ANALYSIS TYPE
if not self.existing_prot:
risk_analysis = "precalc"
# Hardwire in the protection standards for the Netherlands or Average prot standard for a whole unit (i.e. country)
# here self.exposure should be allways urban_damage_v2
prot_pres = (1000 if geogunit_name in ['Noord-Brabant, Netherlands', 'Zeeland, Netherlands',
'Zeeuwse meren, Netherlands', 'Zuid-Holland, Netherlands',
'Drenthe, Netherlands', 'Flevoland, Netherlands',
'Friesland, Netherlands', 'Gelderland, Netherlands',
'Groningen, Netherlands', 'IJsselmeer, Netherlands',
'Limburg, Netherlands', 'Noord-Holland, Netherlands',
'Overijssel, Netherlands', 'Utrecht, Netherlands',
'Netherlands'] else df_precalc[
["_".join(['urban_damage_v2', '2010', scen_abb, "prot_avg"])]])
else:
risk_analysis = "calc"
prot_pres = self.existing_prot
return geogunit, geogunit_name, geogunit_type.lower(), clim, socio, scen_abb, sub_abb, df_precalc, prot_pres, risk_analysis
def lp_data(self):
inFormat = 'raw_agg_{:s}_{:s}_{:s}'.format(self.flood, self.geogunit_type, self.exposure)
cols = [
'{0} as {1}'.format(col, col.replace(self.clim, 'lp').replace(self.socio + "_" + self.sub_abb + "_", ''))
for col in sqlalchemy.Table(inFormat, self.metadata).columns.keys() if
(self.clim in col) and (self.socio in col) and (self.sub_abb in col)]
df_temp = pd.read_sql_query(
"SELECT {0} FROM {1} where id like '{2}'".format(', '.join(cols), inFormat, self.geogunit_name),
self.engine)
df_lpcurve = df_temp.T
df1 = df_lpcurve.reset_index().rename(columns={"index": "index", 0: "y"})
df2 = df_lpcurve.reset_index()['index'].str.split('_', expand=True).rename(
columns={0: "lp", 1: "c", 2: "year", 3: "x"})
logging.info('[RISK]: lp_curve')
#logging.info(df1)
#logging.info(df2)
return pd.concat([df1, df2], axis=1).reindex(df1.index)[['c', 'year', 'y', 'x']].replace(self.rps_names, self.rps)
#return pd.concat([df1, df2], axis=1, join_axes=[df1.index])[['c', 'year', 'y', 'x']].replace(self.rps_names, self.rps)
def bench(self):
defaultfn = "precalc_agg_{0}_{1}_{2}".format(self.flood, self.geogunit_type, self.sub_abb)
print(defaultfn)
# cols = ['{0} as {1}'.format(col, col.replace(self.exposure, 'bench').replace('urban_damage_v2', 'bench').replace("_"+ self.scen_abb, '')) for col in sqlalchemy.Table(defaultfn, self.metadata).columns.keys() if ((self.exposure in col) or ('urban_damage_v2' in col)) and (self.scen_abb in col) and ("cc" not in col) and ("soc" not in col) and ("sub" not in col) and ("avg" in col)]
cols = ['{0} as {1}'.format(col,
col.replace(self.exposure, 'bench').replace('urban_damage_v2', 'bench').replace(
"_" + self.scen_abb, '')) for col in
sqlalchemy.Table(defaultfn, self.metadata).columns.keys() if
((self.exposure in col) or ('prot' in col)) and (self.scen_abb in col) and ("cc" not in col) and (
"soc" not in col) and ("sub" not in col) and ("avg" in col)]
benchData = pd.read_sql_query("SELECT id, {0} FROM {1}".format(', '.join(cols), defaultfn), self.engine,
index_col='id')
return benchData
def format_risk(self, dataframe):
datalist = ["tot_avg", "tot_min", "tot_max",
"ast", "prot_avg",
"per_avg", "per_min", "per_max",
"cc_avg", "cc_min", "cc_max",
"soc_avg", "sub_avg"]
colNames = ["Annual_Damage_Avg", "Annual_Damage_Min", "Annual_Damage_Max",
"Asset_Value", "Flood_Protection",
"Percent_Damage_Avg", "Percent_Damage_Min", "Percent_Damage_Max",
"CC_Driver_Avg", "CC_Driver_Min", "CC_Driver_Max",
"Soc_Driver", "Sub_Driver"]
df_final = pd.DataFrame(index=self.ys, columns=colNames)
for d in range(0, len(datalist)):
selData = dataframe[[col for col in dataframe.columns.tolist() if (datalist[d] in col)]]
if len(selData.values[0]) == 3:
df_final[colNames[d]][1:] = selData.values[0]
else:
df_final[colNames[d]] = selData.values[0]
return df_final
def find_assets(self):
"""
Purpose: Find total asset value
Output:
df_aggregate = Annual impacts for each year for user-selected geographical unit
"""
# Create term to filter out unnecessary results. Drop SSP2 data if scenario
# is pessemistic. Else, drop SSP3
dropex = "ssp2" if self.scen_abb == "pes" else "ssp3"
assts = self.df_precalc[[col for col in self.df_precalc.columns.tolist() if
(self.exposure in col) and (self.scen_abb in col) and ("ast" in col) and (
dropex not in col)]]
return assts.reset_index(drop=True)
def run_stats(self, dataframe):
"""
Purpose: Finds the average, min, and max impact for all impact types
Input:
dataframe: Data associated with flood, geography, exposure type for all climate models
Output:
Dataframe with average impact data for each year for each impact type. Also includes min and max (uncertainity)
"""
# Create dataframe to hold final data
df_final = pd.DataFrame(index=dataframe.index)
# Define column field name structure
colFormat = '{:s}_{:s}_{:s}_{:s}_{:s}'.format
# Run following analysis for each year and impact type
for y in self.ys:
for t in ["cc", "soc", "sub", "tot", "prot"]:
df_filt = dataframe[[col for col in dataframe.columns if (t in col) and (y in col)]]
df_final[colFormat(self.exposure, y, self.scen_abb, t, "avg")] = df_filt.mean(axis=1)
if y != '2010' and t == "tot" or y != '2010' and t == 'cc':
df_final[colFormat(self.exposure, y, self.scen_abb, t, "min")] = df_filt.min(axis=1)
df_final[colFormat(self.exposure, y, self.scen_abb, t, "max")] = df_filt.max(axis=1)
df_final.replace(np.nan, 0, inplace=True)
return df_final
def ratio_to_total(self, dataframe):
"""
Purpose: Finds the impact attributed to climate change only, socioecon only, and subsidence only
Input:
inData: Annual expected impact data (found using default_risk function)
mods: All possible climate models
Output:
Dataframe with final impact data for each year for each impact type. Column name also specifies given model
"""
# Create dataframe to hold final data
df_final = pd.DataFrame(index=dataframe.index)
# Run analysis for each climate model and each year past 2010
colFormat = '{:s}_{:s}_{:s}_{:s}_{:s}'.format
df_final[colFormat(self.exposure, "2010", self.scen_abb, "prot", "avg")] = dataframe[
colFormat(self.exposure, "2010", self.scen_abb, "prot", "avg")]
tot2010 = dataframe[colFormat(self.exposure, "2010", self.scen_abb, "tot", "avg")]
df_final[colFormat(self.exposure, "2010", self.scen_abb, "tot", "avg")] = tot2010
for y in self.ys[1:]:
# Filter data year
df_filt = dataframe[[col for col in dataframe.columns if (y in col)]]
# Total impact for selected year is already calculated
df_final[colFormat(self.exposure, y, self.scen_abb, "tot", "avg")] = dataframe[
colFormat(self.exposure, y, self.scen_abb, "tot", "avg")]
df_final[colFormat(self.exposure, y, self.scen_abb, "tot", "min")] = dataframe[
colFormat(self.exposure, y, self.scen_abb, "tot", "min")]
df_final[colFormat(self.exposure, y, self.scen_abb, "tot", "max")] = dataframe[
colFormat(self.exposure, y, self.scen_abb, "tot", "max")]
# Find the difference from each impact to the 2010 baseline data
df_filt['tot_diff'] = dataframe[colFormat(self.exposure, y, self.scen_abb, "tot",
"avg")] - tot2010 # Total impact
df_filt['cc_diff_avg'] = dataframe[colFormat(self.exposure, y, self.scen_abb, "cc",
"avg")] - tot2010 # Total impact
df_filt['cc_diff_min'] = dataframe[colFormat(self.exposure, y, self.scen_abb, "cc",
"min")] - tot2010 # Total impact
df_filt['cc_diff_max'] = dataframe[colFormat(self.exposure, y, self.scen_abb, "cc",
"max")] - tot2010 # Total impact
df_filt['soc_diff'] = dataframe[colFormat(self.exposure, y, self.scen_abb, "soc",
"avg")] - tot2010 # Total impact#Soc only impact
df_filt['sub_diff'] = dataframe[colFormat(self.exposure, y, self.scen_abb, "sub",
"avg")] - tot2010 # Total impact #Subsidence only impact
# Correct for values if impact is less than 2010 baseline data
df_filt['cc_diff_avg'] = np.where(df_filt['tot_diff'] > 0,
np.where(df_filt['cc_diff_avg'] < 0, 0, df_filt['cc_diff_avg']),
np.where(df_filt['cc_diff_avg'] > 0, 0, df_filt['cc_diff_avg']))
df_filt['cc_diff_min'] = np.where(df_filt['tot_diff'] > 0,
np.where(df_filt['cc_diff_min'] < 0, 0, df_filt['cc_diff_min']),
np.where(df_filt['cc_diff_min'] > 0, 0, df_filt['cc_diff_min']))
df_filt['cc_diff_max'] = np.where(df_filt['tot_diff'] > 0,
np.where(df_filt['cc_diff_max'] < 0, 0, df_filt['cc_diff_max']),
| np.where(df_filt['cc_diff_max'] > 0, 0, df_filt['cc_diff_max']) | numpy.where |
import numpy as np
import matplotlib.pyplot as plt
def boot(data, statistic, R):
from numpy import zeros, arange, mean, std, loadtxt
from numpy.random import randint
from time import time
t = zeros(R); n = len(data); inds = arange(n); t0 = time()
# non-parametric bootstrap
for i in range(R):
t[i] = statistic(data[randint(0,n,n)])
return t
def tsboot(data,statistic,R,l):
from numpy import std, mean, concatenate, arange, loadtxt, zeros, ceil
from numpy.random import randint
from time import time
t = zeros(R); n = len(data); k = int(ceil(float(n)/l));
inds = | arange(n) | numpy.arange |
import os.path as op
import glob
import numpy as np
import mne
import matplotlib.pyplot as plt
with open('./eeg_file_list.txt', 'r') as fid:
file_list = fid.read().split('\n')[:-1]
subjects = list({ff.split('_')[0] for ff in file_list})
out_path = op.expanduser('~/study_data/LEMON/EEG_Preprocessed')
ref_info = mne.io.read_info("lemon-ref-info.fif")
cov_fnames = glob.glob("./derivatives/sub-??????-alpha-cov.fif")
cov_egivals = list()
for fname in cov_fnames:
cov = mne.read_cov(fname)
eigvals = | np.linalg.svd(cov.data, full_matrices=True) | numpy.linalg.svd |
import os
import re
import numpy as np
def read_log_file(root_dir, file_name_list):
losses = []
for file_name in file_name_list:
i = 0
with open(os.path.join(root_dir, file_name), 'r') as log_file:
for line in log_file:
match_cost = re.findall('train_cost: [-+]?[0-9]*\.?[0-9]*', line)
if len(match_cost) > 0:
loss = float(match_cost[0].split(": ")[1])
losses.append(loss)
return | np.array(losses) | numpy.array |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.